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/androidx/lifecycle/A.java

@@ -0,0 +1,68 @@
+package androidx.lifecycle;
+
+/* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
+/* JADX WARN: Unknown enum class pattern. Please report as an issue! */
+/* loaded from: classes.dex */
+public final class A {
+    private static final /* synthetic */ A[] $VALUES;
+    public static final C0203y Companion;
+    public static final A ON_ANY;
+    public static final A ON_CREATE;
+    public static final A ON_DESTROY;
+    public static final A ON_PAUSE;
+    public static final A ON_RESUME;
+    public static final A ON_START;
+    public static final A ON_STOP;
+
+    /* JADX WARN: Type inference failed for: r0v0, types: [java.lang.Enum, androidx.lifecycle.A] */
+    /* JADX WARN: Type inference failed for: r0v2, types: [java.lang.Object, androidx.lifecycle.y] */
+    /* JADX WARN: Type inference failed for: r1v1, types: [java.lang.Enum, androidx.lifecycle.A] */
+    /* JADX WARN: Type inference failed for: r2v2, types: [java.lang.Enum, androidx.lifecycle.A] */
+    /* JADX WARN: Type inference failed for: r3v2, types: [java.lang.Enum, androidx.lifecycle.A] */
+    /* JADX WARN: Type inference failed for: r4v2, types: [java.lang.Enum, androidx.lifecycle.A] */
+    /* JADX WARN: Type inference failed for: r5v2, types: [java.lang.Enum, androidx.lifecycle.A] */
+    /* JADX WARN: Type inference failed for: r6v2, types: [java.lang.Enum, androidx.lifecycle.A] */
+    static {
+        ?? r02 = new Enum("ON_CREATE", 0);
+        ON_CREATE = r02;
+        ?? r12 = new Enum("ON_START", 1);
+        ON_START = r12;
+        ?? r22 = new Enum("ON_RESUME", 2);
+        ON_RESUME = r22;
+        ?? r32 = new Enum("ON_PAUSE", 3);
+        ON_PAUSE = r32;
+        ?? r4 = new Enum("ON_STOP", 4);
+        ON_STOP = r4;
+        ?? r5 = new Enum("ON_DESTROY", 5);
+        ON_DESTROY = r5;
+        ?? r6 = new Enum("ON_ANY", 6);
+        ON_ANY = r6;
+        $VALUES = new A[]{r02, r12, r22, r32, r4, r5, r6};
+        Companion = new Object();
+    }
+
+    public static A valueOf(String str) {
+        return (A) Enum.valueOf(A.class, str);
+    }
+
+    public static A[] values() {
+        return (A[]) $VALUES.clone();
+    }
+
+    public final B a() {
+        switch (AbstractC0204z.$EnumSwitchMapping$0[ordinal()]) {
+            case 1:
+            case 2:
+                return B.f3282c;
+            case 3:
+            case 4:
+                return B.f3283d;
+            case 5:
+                return B.f3284e;
+            case 6:
+                return B.f3280a;
+            default:
+                throw new IllegalArgumentException(this + " has no target state");
+        }
+    }
+}

apk_decompiled/sources/androidx/lifecycle/A0.java

@@ -0,0 +1,6 @@
+package androidx.lifecycle;
+
+/* loaded from: classes.dex */
+public abstract class A0 {
+    public abstract void a(w0 w0Var);
+}

apk_decompiled/sources/androidx/lifecycle/AbstractC0176a.java

@@ -0,0 +1,6 @@
+package androidx.lifecycle;
+
+/* renamed from: androidx.lifecycle.a, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0176a extends w0 {
+}

apk_decompiled/sources/androidx/lifecycle/AbstractC0177a0.java

@@ -0,0 +1,17 @@
+package androidx.lifecycle;
+
+import android.app.Activity;
+import android.app.Application;
+import kotlin.jvm.JvmStatic;
+import kotlin.jvm.internal.Intrinsics;
+
+/* renamed from: androidx.lifecycle.a0, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0177a0 {
+    @JvmStatic
+    public static final void a(Activity activity, Application.ActivityLifecycleCallbacks callback) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        activity.registerActivityLifecycleCallbacks(callback);
+    }
+}

apk_decompiled/sources/androidx/lifecycle/AbstractC0193n.java

@@ -0,0 +1,40 @@
+package androidx.lifecycle;
+
+/* renamed from: androidx.lifecycle.n, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class AbstractC0193n {
+    public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+    static {
+        int[] iArr = new int[A.values().length];
+        try {
+            iArr[A.ON_CREATE.ordinal()] = 1;
+        } catch (NoSuchFieldError unused) {
+        }
+        try {
+            iArr[A.ON_START.ordinal()] = 2;
+        } catch (NoSuchFieldError unused2) {
+        }
+        try {
+            iArr[A.ON_RESUME.ordinal()] = 3;
+        } catch (NoSuchFieldError unused3) {
+        }
+        try {
+            iArr[A.ON_PAUSE.ordinal()] = 4;
+        } catch (NoSuchFieldError unused4) {
+        }
+        try {
+            iArr[A.ON_STOP.ordinal()] = 5;
+        } catch (NoSuchFieldError unused5) {
+        }
+        try {
+            iArr[A.ON_DESTROY.ordinal()] = 6;
+        } catch (NoSuchFieldError unused6) {
+        }
+        try {
+            iArr[A.ON_ANY.ordinal()] = 7;
+        } catch (NoSuchFieldError unused7) {
+        }
+        $EnumSwitchMapping$0 = iArr;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/AbstractC0197s.java

@@ -0,0 +1,46 @@
+package androidx.lifecycle;
+
+import android.app.Activity;
+import android.app.Application;
+import android.os.Bundle;
+import kotlin.jvm.internal.Intrinsics;
+
+/* renamed from: androidx.lifecycle.s, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0197s implements Application.ActivityLifecycleCallbacks {
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityCreated(Activity activity, Bundle bundle) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityDestroyed(Activity activity) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityPaused(Activity activity) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityResumed(Activity activity) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+        Intrinsics.checkNotNullParameter(outState, "outState");
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityStarted(Activity activity) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityStopped(Activity activity) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+    }
+}

apk_decompiled/sources/androidx/lifecycle/AbstractC0202x.java

@@ -0,0 +1,32 @@
+package androidx.lifecycle;
+
+/* renamed from: androidx.lifecycle.x, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class AbstractC0202x {
+    public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+    static {
+        int[] iArr = new int[B.values().length];
+        try {
+            iArr[2] = 1;
+        } catch (NoSuchFieldError unused) {
+        }
+        try {
+            iArr[3] = 2;
+        } catch (NoSuchFieldError unused2) {
+        }
+        try {
+            iArr[4] = 3;
+        } catch (NoSuchFieldError unused3) {
+        }
+        try {
+            iArr[0] = 4;
+        } catch (NoSuchFieldError unused4) {
+        }
+        try {
+            iArr[1] = 5;
+        } catch (NoSuchFieldError unused5) {
+        }
+        $EnumSwitchMapping$0 = iArr;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/AbstractC0204z.java

@@ -0,0 +1,40 @@
+package androidx.lifecycle;
+
+/* renamed from: androidx.lifecycle.z, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class AbstractC0204z {
+    public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+    static {
+        int[] iArr = new int[A.values().length];
+        try {
+            iArr[A.ON_CREATE.ordinal()] = 1;
+        } catch (NoSuchFieldError unused) {
+        }
+        try {
+            iArr[A.ON_STOP.ordinal()] = 2;
+        } catch (NoSuchFieldError unused2) {
+        }
+        try {
+            iArr[A.ON_START.ordinal()] = 3;
+        } catch (NoSuchFieldError unused3) {
+        }
+        try {
+            iArr[A.ON_PAUSE.ordinal()] = 4;
+        } catch (NoSuchFieldError unused4) {
+        }
+        try {
+            iArr[A.ON_RESUME.ordinal()] = 5;
+        } catch (NoSuchFieldError unused5) {
+        }
+        try {
+            iArr[A.ON_DESTROY.ordinal()] = 6;
+        } catch (NoSuchFieldError unused6) {
+        }
+        try {
+            iArr[A.ON_ANY.ordinal()] = 7;
+        } catch (NoSuchFieldError unused7) {
+        }
+        $EnumSwitchMapping$0 = iArr;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/B.java

@@ -0,0 +1,60 @@
+package androidx.lifecycle;
+
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.debug.internal.DebugCoroutineInfoImplKt;
+
+/* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
+/* JADX WARN: Unknown enum class pattern. Please report as an issue! */
+/* loaded from: classes.dex */
+public final class B {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final B f3280a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final B f3281b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public static final B f3282c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public static final B f3283d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public static final B f3284e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public static final /* synthetic */ B[] f3285f;
+
+    /* JADX WARN: Type inference failed for: r0v0, types: [java.lang.Enum, androidx.lifecycle.B] */
+    /* JADX WARN: Type inference failed for: r1v1, types: [java.lang.Enum, androidx.lifecycle.B] */
+    /* JADX WARN: Type inference failed for: r2v2, types: [java.lang.Enum, androidx.lifecycle.B] */
+    /* JADX WARN: Type inference failed for: r3v2, types: [java.lang.Enum, androidx.lifecycle.B] */
+    /* JADX WARN: Type inference failed for: r4v2, types: [java.lang.Enum, androidx.lifecycle.B] */
+    static {
+        ?? r02 = new Enum("DESTROYED", 0);
+        f3280a = r02;
+        ?? r12 = new Enum("INITIALIZED", 1);
+        f3281b = r12;
+        ?? r22 = new Enum(DebugCoroutineInfoImplKt.CREATED, 2);
+        f3282c = r22;
+        ?? r32 = new Enum("STARTED", 3);
+        f3283d = r32;
+        ?? r4 = new Enum("RESUMED", 4);
+        f3284e = r4;
+        f3285f = new B[]{r02, r12, r22, r32, r4};
+    }
+
+    public static B valueOf(String str) {
+        return (B) Enum.valueOf(B.class, str);
+    }
+
+    public static B[] values() {
+        return (B[]) f3285f.clone();
+    }
+
+    public final boolean a(B state) {
+        Intrinsics.checkNotNullParameter(state, "state");
+        return compareTo(state) >= 0;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/B0.java

@@ -0,0 +1,23 @@
+package androidx.lifecycle;
+
+import kotlin.jvm.internal.Intrinsics;
+import l0.C0435a;
+
+/* loaded from: classes.dex */
+public final class B0 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final R0.h f3286a;
+
+    public B0(D0 owner, y0 factory) {
+        Intrinsics.checkNotNullParameter(owner, "owner");
+        Intrinsics.checkNotNullParameter(factory, "factory");
+        C0 store = owner.getViewModelStore();
+        Intrinsics.checkNotNullParameter(owner, "owner");
+        l0.c defaultCreationExtras = owner instanceof InterfaceC0200v ? ((InterfaceC0200v) owner).getDefaultViewModelCreationExtras() : C0435a.f7312b;
+        Intrinsics.checkNotNullParameter(store, "store");
+        Intrinsics.checkNotNullParameter(factory, "factory");
+        Intrinsics.checkNotNullParameter(defaultCreationExtras, "defaultCreationExtras");
+        this.f3286a = new R0.h(store, factory, defaultCreationExtras);
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C.java

@@ -0,0 +1,16 @@
+package androidx.lifecycle;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes.dex */
+public abstract class C {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final AtomicReference f3287a = new AtomicReference(null);
+
+    public abstract void a(I i);
+
+    public abstract B b();
+
+    public abstract void c(I i);
+}

apk_decompiled/sources/androidx/lifecycle/C0.java

@@ -0,0 +1,20 @@
+package androidx.lifecycle;
+
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+
+/* loaded from: classes.dex */
+public final class C0 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final LinkedHashMap f3288a = new LinkedHashMap();
+
+    public final void a() {
+        LinkedHashMap linkedHashMap = this.f3288a;
+        Iterator it = linkedHashMap.values().iterator();
+        while (it.hasNext()) {
+            ((w0) it.next()).clear$lifecycle_viewmodel_release();
+        }
+        linkedHashMap.clear();
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C0178b.java

@@ -0,0 +1,67 @@
+package androidx.lifecycle;
+
+import java.util.concurrent.CancellationException;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+import kotlinx.coroutines.DelayKt;
+import kotlinx.coroutines.Job;
+
+/* renamed from: androidx.lifecycle.b, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0178b extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f3332a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ C0182d f3333b;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public C0178b(C0182d c0182d, Continuation continuation) {
+        super(2, continuation);
+        this.f3333b = c0182d;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new C0178b(this.f3333b, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((C0178b) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f3332a;
+        C0182d c0182d = this.f3333b;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            c0182d.getClass();
+            this.f3332a = 1;
+            if (DelayKt.delay(5000L, this) == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        if (c0182d.f3344a.f3314c <= 0) {
+            Job job = c0182d.f3348e;
+            if (job != null) {
+                Job.DefaultImpls.cancel$default(job, (CancellationException) null, 1, (Object) null);
+            }
+            c0182d.f3348e = null;
+        }
+        return Unit.INSTANCE;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C0179b0.java

@@ -0,0 +1,92 @@
+package androidx.lifecycle;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.os.Handler;
+import kotlin.jvm.internal.Intrinsics;
+
+/* renamed from: androidx.lifecycle.b0, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0179b0 extends AbstractC0197s {
+    final /* synthetic */ C0181c0 this$0;
+
+    /* renamed from: androidx.lifecycle.b0$a */
+    /* loaded from: classes.dex */
+    public static final class a extends AbstractC0197s {
+        final /* synthetic */ C0181c0 this$0;
+
+        public a(C0181c0 c0181c0) {
+            this.this$0 = c0181c0;
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityPostResumed(Activity activity) {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+            C0181c0 c0181c0 = this.this$0;
+            int i = c0181c0.f3338b + 1;
+            c0181c0.f3338b = i;
+            if (i == 1) {
+                if (c0181c0.f3339c) {
+                    c0181c0.f3342f.f(A.ON_RESUME);
+                    c0181c0.f3339c = false;
+                } else {
+                    Handler handler = c0181c0.f3341e;
+                    Intrinsics.checkNotNull(handler);
+                    handler.removeCallbacks(c0181c0.f3343g);
+                }
+            }
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityPostStarted(Activity activity) {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+            C0181c0 c0181c0 = this.this$0;
+            int i = c0181c0.f3337a + 1;
+            c0181c0.f3337a = i;
+            if (i == 1 && c0181c0.f3340d) {
+                c0181c0.f3342f.f(A.ON_START);
+                c0181c0.f3340d = false;
+            }
+        }
+    }
+
+    public C0179b0(C0181c0 c0181c0) {
+        this.this$0 = c0181c0;
+    }
+
+    @Override // androidx.lifecycle.AbstractC0197s, android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityCreated(Activity activity, Bundle bundle) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+    }
+
+    @Override // androidx.lifecycle.AbstractC0197s, android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityPaused(Activity activity) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+        C0181c0 c0181c0 = this.this$0;
+        int i = c0181c0.f3338b - 1;
+        c0181c0.f3338b = i;
+        if (i == 0) {
+            Handler handler = c0181c0.f3341e;
+            Intrinsics.checkNotNull(handler);
+            handler.postDelayed(c0181c0.f3343g, 700L);
+        }
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityPreCreated(Activity activity, Bundle bundle) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+        AbstractC0177a0.a(activity, new a(this.this$0));
+    }
+
+    @Override // androidx.lifecycle.AbstractC0197s, android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityStopped(Activity activity) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+        C0181c0 c0181c0 = this.this$0;
+        int i = c0181c0.f3337a - 1;
+        c0181c0.f3337a = i;
+        if (i == 0 && c0181c0.f3339c) {
+            c0181c0.f3342f.f(A.ON_STOP);
+            c0181c0.f3340d = true;
+        }
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C0180c.java

@@ -0,0 +1,65 @@
+package androidx.lifecycle;
+
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+/* renamed from: androidx.lifecycle.c, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0180c extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f3334a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public /* synthetic */ Object f3335b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ C0182d f3336c;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public C0180c(C0182d c0182d, Continuation continuation) {
+        super(2, continuation);
+        this.f3336c = c0182d;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        C0180c c0180c = new C0180c(this.f3336c, continuation);
+        c0180c.f3335b = obj;
+        return c0180c;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((C0180c) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    /* JADX WARN: Type inference failed for: r6v4, types: [kotlin.coroutines.jvm.internal.SuspendLambda, kotlin.jvm.functions.Function2] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f3334a;
+        C0182d c0182d = this.f3336c;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            U u3 = new U(c0182d.f3344a, ((CoroutineScope) this.f3335b).getCoroutineContext());
+            ?? r6 = c0182d.f3345b;
+            this.f3334a = 1;
+            if (r6.invoke(u3, this) == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        c0182d.f3347d.invoke();
+        return Unit.INSTANCE;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C0181c0.java

@@ -0,0 +1,35 @@
+package androidx.lifecycle;
+
+import android.os.Handler;
+
+/* renamed from: androidx.lifecycle.c0, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0181c0 implements J {
+    public static final C0181c0 h = new C0181c0();
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f3337a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public int f3338b;
+
+    /* renamed from: e, reason: collision with root package name */
+    public Handler f3341e;
+
+    /* renamed from: c, reason: collision with root package name */
+    public boolean f3339c = true;
+
+    /* renamed from: d, reason: collision with root package name */
+    public boolean f3340d = true;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final L f3342f = new L(this);
+
+    /* renamed from: g, reason: collision with root package name */
+    public final F2.f f3343g = new F2.f(this, 4);
+
+    @Override // androidx.lifecycle.J
+    public final C getLifecycle() {
+        return this.f3342f;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C0182d.java

@@ -0,0 +1,42 @@
+package androidx.lifecycle;
+
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.CoroutineScope;
+import kotlinx.coroutines.Job;
+
+/* renamed from: androidx.lifecycle.d, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0182d {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final C0189j f3344a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final SuspendLambda f3345b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final CoroutineScope f3346c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final J0.e f3347d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public Job f3348e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public Job f3349f;
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public C0182d(C0189j liveData, Function2 block, CoroutineScope scope, J0.e onDone) {
+        Intrinsics.checkNotNullParameter(liveData, "liveData");
+        Intrinsics.checkNotNullParameter(block, "block");
+        Intrinsics.checkNotNullParameter(scope, "scope");
+        Intrinsics.checkNotNullParameter(onDone, "onDone");
+        this.f3344a = liveData;
+        this.f3345b = (SuspendLambda) block;
+        this.f3346c = scope;
+        this.f3347d = onDone;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C0183d0.java

@@ -0,0 +1,61 @@
+package androidx.lifecycle;
+
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+/* renamed from: androidx.lifecycle.d0, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0183d0 extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f3350a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public /* synthetic */ Object f3351b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ Function2 f3352c;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public C0183d0(Function2 function2, Continuation continuation) {
+        super(2, continuation);
+        this.f3352c = function2;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        C0183d0 c0183d0 = new C0183d0(this.f3352c, continuation);
+        c0183d0.f3351b = obj;
+        return c0183d0;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((C0183d0) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f3350a;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            CoroutineScope coroutineScope = (CoroutineScope) this.f3351b;
+            this.f3350a = 1;
+            if (this.f3352c.invoke(coroutineScope, this) == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        return Unit.INSTANCE;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C0184e.java

@@ -0,0 +1,56 @@
+package androidx.lifecycle;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/* renamed from: androidx.lifecycle.e, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0184e {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final HashMap f3353a = new HashMap();
+
+    /* renamed from: b, reason: collision with root package name */
+    public final HashMap f3354b;
+
+    public C0184e(HashMap hashMap) {
+        this.f3354b = hashMap;
+        for (Map.Entry entry : hashMap.entrySet()) {
+            A a2 = (A) entry.getValue();
+            List list = (List) this.f3353a.get(a2);
+            if (list == null) {
+                list = new ArrayList();
+                this.f3353a.put(a2, list);
+            }
+            list.add((C0185f) entry.getKey());
+        }
+    }
+
+    public static void a(List list, J j4, A a2, I i) {
+        if (list != null) {
+            for (int size = list.size() - 1; size >= 0; size--) {
+                C0185f c0185f = (C0185f) list.get(size);
+                c0185f.getClass();
+                try {
+                    int i4 = c0185f.f3360a;
+                    Method method = c0185f.f3361b;
+                    if (i4 == 0) {
+                        method.invoke(i, new Object[0]);
+                    } else if (i4 == 1) {
+                        method.invoke(i, j4);
+                    } else if (i4 == 2) {
+                        method.invoke(i, j4, a2);
+                    }
+                } catch (IllegalAccessException e4) {
+                    throw new RuntimeException(e4);
+                } catch (InvocationTargetException e5) {
+                    throw new RuntimeException("Failed to call observer method", e5.getCause());
+                }
+            }
+        }
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C0185f.java

@@ -0,0 +1,35 @@
+package androidx.lifecycle;
+
+import java.lang.reflect.Method;
+
+/* renamed from: androidx.lifecycle.f, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0185f {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final int f3360a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final Method f3361b;
+
+    public C0185f(Method method, int i) {
+        this.f3360a = i;
+        this.f3361b = method;
+        method.setAccessible(true);
+    }
+
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof C0185f)) {
+            return false;
+        }
+        C0185f c0185f = (C0185f) obj;
+        return this.f3360a == c0185f.f3360a && this.f3361b.getName().equals(c0185f.f3361b.getName());
+    }
+
+    public final int hashCode() {
+        return this.f3361b.getName().hashCode() + (this.f3360a * 31);
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C0186g.java

@@ -0,0 +1,95 @@
+package androidx.lifecycle;
+
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+/* renamed from: androidx.lifecycle.g, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0186g {
+
+    /* renamed from: c, reason: collision with root package name */
+    public static final C0186g f3369c = new C0186g();
+
+    /* renamed from: a, reason: collision with root package name */
+    public final HashMap f3370a = new HashMap();
+
+    /* renamed from: b, reason: collision with root package name */
+    public final HashMap f3371b = new HashMap();
+
+    public static void b(HashMap hashMap, C0185f c0185f, A a2, Class cls) {
+        A a4 = (A) hashMap.get(c0185f);
+        if (a4 == null || a2 == a4) {
+            if (a4 == null) {
+                hashMap.put(c0185f, a2);
+                return;
+            }
+            return;
+        }
+        throw new IllegalArgumentException("Method " + c0185f.f3361b.getName() + " in " + cls.getName() + " already declared with different @OnLifecycleEvent value: previous value " + a4 + ", new value " + a2);
+    }
+
+    public final C0184e a(Class cls, Method[] methodArr) {
+        int i;
+        Class superclass = cls.getSuperclass();
+        HashMap hashMap = new HashMap();
+        HashMap hashMap2 = this.f3370a;
+        if (superclass != null) {
+            C0184e c0184e = (C0184e) hashMap2.get(superclass);
+            if (c0184e == null) {
+                c0184e = a(superclass, null);
+            }
+            hashMap.putAll(c0184e.f3354b);
+        }
+        for (Class<?> cls2 : cls.getInterfaces()) {
+            C0184e c0184e2 = (C0184e) hashMap2.get(cls2);
+            if (c0184e2 == null) {
+                c0184e2 = a(cls2, null);
+            }
+            for (Map.Entry entry : c0184e2.f3354b.entrySet()) {
+                b(hashMap, (C0185f) entry.getKey(), (A) entry.getValue(), cls);
+            }
+        }
+        if (methodArr == null) {
+            try {
+                methodArr = cls.getDeclaredMethods();
+            } catch (NoClassDefFoundError e4) {
+                throw new IllegalArgumentException("The observer class has some methods that use newer APIs which are not available in the current OS version. Lifecycles cannot access even other methods so you should make sure that your observer classes only access framework classes that are available in your min API level OR use lifecycle:compiler annotation processor.", e4);
+            }
+        }
+        boolean z3 = false;
+        for (Method method : methodArr) {
+            Z z4 = (Z) method.getAnnotation(Z.class);
+            if (z4 != null) {
+                Class<?>[] parameterTypes = method.getParameterTypes();
+                if (parameterTypes.length <= 0) {
+                    i = 0;
+                } else {
+                    if (!J.class.isAssignableFrom(parameterTypes[0])) {
+                        throw new IllegalArgumentException("invalid parameter type. Must be one and instanceof LifecycleOwner");
+                    }
+                    i = 1;
+                }
+                A value = z4.value();
+                if (parameterTypes.length > 1) {
+                    if (!A.class.isAssignableFrom(parameterTypes[1])) {
+                        throw new IllegalArgumentException("invalid parameter type. second arg must be an event");
+                    }
+                    if (value != A.ON_ANY) {
+                        throw new IllegalArgumentException("Second arg is supported only for ON_ANY value");
+                    }
+                    i = 2;
+                }
+                if (parameterTypes.length > 2) {
+                    throw new IllegalArgumentException("cannot have more than 2 params");
+                }
+                b(hashMap, new C0185f(method, i), value, cls);
+                z3 = true;
+            }
+        }
+        C0184e c0184e3 = new C0184e(hashMap);
+        hashMap2.put(cls, c0184e3);
+        this.f3371b.put(cls, Boolean.valueOf(z3));
+        return c0184e3;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C0187h.java

@@ -0,0 +1,34 @@
+package androidx.lifecycle;
+
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.jvm.internal.IntCompanionObject;
+
+/* renamed from: androidx.lifecycle.h, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0187h extends ContinuationImpl {
+
+    /* renamed from: a, reason: collision with root package name */
+    public C0189j f3379a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public /* synthetic */ Object f3380b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ C0189j f3381c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public int f3382d;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public C0187h(C0189j c0189j, ContinuationImpl continuationImpl) {
+        super(continuationImpl);
+        this.f3381c = c0189j;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        this.f3380b = obj;
+        this.f3382d |= IntCompanionObject.MIN_VALUE;
+        return this.f3381c.l(this);
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C0188i.java

@@ -0,0 +1,37 @@
+package androidx.lifecycle;
+
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.jvm.internal.IntCompanionObject;
+
+/* renamed from: androidx.lifecycle.i, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0188i extends ContinuationImpl {
+
+    /* renamed from: a, reason: collision with root package name */
+    public C0189j f3387a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public Q f3388b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public /* synthetic */ Object f3389c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ C0189j f3390d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public int f3391e;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public C0188i(C0189j c0189j, ContinuationImpl continuationImpl) {
+        super(continuationImpl);
+        this.f3390d = c0189j;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        this.f3389c = obj;
+        this.f3391e |= IntCompanionObject.MIN_VALUE;
+        return this.f3390d.m(null, this);
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C0189j.java

@@ -0,0 +1,204 @@
+package androidx.lifecycle;
+
+import java.util.concurrent.CancellationException;
+import kotlinx.coroutines.BuildersKt__Builders_commonKt;
+import kotlinx.coroutines.Dispatchers;
+import kotlinx.coroutines.Job;
+
+/* renamed from: androidx.lifecycle.j, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0189j extends W {
+
+    /* renamed from: m, reason: collision with root package name */
+    public C0182d f3392m;
+
+    /* renamed from: n, reason: collision with root package name */
+    public r f3393n;
+
+    @Override // androidx.lifecycle.W, androidx.lifecycle.Q
+    public final void g() {
+        Job launch$default;
+        super.g();
+        C0182d c0182d = this.f3392m;
+        if (c0182d != null) {
+            Job job = c0182d.f3349f;
+            if (job != null) {
+                Job.DefaultImpls.cancel$default(job, (CancellationException) null, 1, (Object) null);
+            }
+            c0182d.f3349f = null;
+            if (c0182d.f3348e != null) {
+                return;
+            }
+            launch$default = BuildersKt__Builders_commonKt.launch$default(c0182d.f3346c, null, null, new C0180c(c0182d, null), 3, null);
+            c0182d.f3348e = launch$default;
+        }
+    }
+
+    @Override // androidx.lifecycle.W, androidx.lifecycle.Q
+    public final void h() {
+        Job launch$default;
+        super.h();
+        C0182d c0182d = this.f3392m;
+        if (c0182d != null) {
+            if (c0182d.f3349f != null) {
+                throw new IllegalStateException("Cancel call cannot happen without a maybeRun");
+            }
+            launch$default = BuildersKt__Builders_commonKt.launch$default(c0182d.f3346c, Dispatchers.getMain().getImmediate(), null, new C0178b(c0182d, null), 2, null);
+            c0182d.f3349f = launch$default;
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:15:0x0034  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0024  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final java.lang.Object l(kotlin.coroutines.jvm.internal.ContinuationImpl r6) {
+        /*
+            r5 = this;
+            boolean r0 = r6 instanceof androidx.lifecycle.C0187h
+            if (r0 == 0) goto L13
+            r0 = r6
+            androidx.lifecycle.h r0 = (androidx.lifecycle.C0187h) r0
+            int r1 = r0.f3382d
+            r2 = -2147483648(0xffffffff80000000, float:-0.0)
+            r3 = r1 & r2
+            if (r3 == 0) goto L13
+            int r1 = r1 - r2
+            r0.f3382d = r1
+            goto L18
+        L13:
+            androidx.lifecycle.h r0 = new androidx.lifecycle.h
+            r0.<init>(r5, r6)
+        L18:
+            java.lang.Object r6 = r0.f3380b
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.f3382d
+            r3 = 0
+            r4 = 1
+            if (r2 == 0) goto L34
+            if (r2 != r4) goto L2c
+            androidx.lifecycle.j r5 = r0.f3379a
+            kotlin.ResultKt.throwOnFailure(r6)
+            goto L5c
+        L2c:
+            java.lang.IllegalStateException r5 = new java.lang.IllegalStateException
+            java.lang.String r6 = "call to 'resume' before 'invoke' with coroutine"
+            r5.<init>(r6)
+            throw r5
+        L34:
+            kotlin.ResultKt.throwOnFailure(r6)
+            androidx.lifecycle.r r6 = r5.f3393n
+            if (r6 == 0) goto L5c
+            r0.f3379a = r5
+            r0.f3382d = r4
+            kotlinx.coroutines.MainCoroutineDispatcher r2 = kotlinx.coroutines.Dispatchers.getMain()
+            kotlinx.coroutines.MainCoroutineDispatcher r2 = r2.getImmediate()
+            androidx.lifecycle.q r4 = new androidx.lifecycle.q
+            r4.<init>(r6, r3)
+            java.lang.Object r6 = kotlinx.coroutines.BuildersKt.withContext(r2, r4, r0)
+            java.lang.Object r0 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            if (r6 != r0) goto L57
+            goto L59
+        L57:
+            kotlin.Unit r6 = kotlin.Unit.INSTANCE
+        L59:
+            if (r6 != r1) goto L5c
+            return r1
+        L5c:
+            r5.f3393n = r3
+            kotlin.Unit r5 = kotlin.Unit.INSTANCE
+            return r5
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.lifecycle.C0189j.l(kotlin.coroutines.jvm.internal.ContinuationImpl):java.lang.Object");
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:18:0x0066, code lost:
+    
+        if (r7 != r1) goto L22;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:19:0x0068, code lost:
+    
+        return r1;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:21:0x004b, code lost:
+    
+        if (l(r0) == r1) goto L21;
+     */
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Removed duplicated region for block: B:20:0x003e  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0024  */
+    /* JADX WARN: Type inference failed for: r6v2, types: [androidx.lifecycle.Q] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final java.lang.Object m(androidx.lifecycle.C0189j r6, kotlin.coroutines.jvm.internal.ContinuationImpl r7) {
+        /*
+            r5 = this;
+            boolean r0 = r7 instanceof androidx.lifecycle.C0188i
+            if (r0 == 0) goto L13
+            r0 = r7
+            androidx.lifecycle.i r0 = (androidx.lifecycle.C0188i) r0
+            int r1 = r0.f3391e
+            r2 = -2147483648(0xffffffff80000000, float:-0.0)
+            r3 = r1 & r2
+            if (r3 == 0) goto L13
+            int r1 = r1 - r2
+            r0.f3391e = r1
+            goto L18
+        L13:
+            androidx.lifecycle.i r0 = new androidx.lifecycle.i
+            r0.<init>(r5, r7)
+        L18:
+            java.lang.Object r7 = r0.f3389c
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.f3391e
+            r3 = 2
+            r4 = 1
+            if (r2 == 0) goto L3e
+            if (r2 == r4) goto L36
+            if (r2 != r3) goto L2e
+            androidx.lifecycle.j r5 = r0.f3387a
+            kotlin.ResultKt.throwOnFailure(r7)
+            goto L69
+        L2e:
+            java.lang.IllegalStateException r5 = new java.lang.IllegalStateException
+            java.lang.String r6 = "call to 'resume' before 'invoke' with coroutine"
+            r5.<init>(r6)
+            throw r5
+        L36:
+            androidx.lifecycle.Q r6 = r0.f3388b
+            androidx.lifecycle.j r5 = r0.f3387a
+            kotlin.ResultKt.throwOnFailure(r7)
+            goto L4e
+        L3e:
+            kotlin.ResultKt.throwOnFailure(r7)
+            r0.f3387a = r5
+            r0.f3388b = r6
+            r0.f3391e = r4
+            java.lang.Object r7 = r5.l(r0)
+            if (r7 != r1) goto L4e
+            goto L68
+        L4e:
+            r0.f3387a = r5
+            r7 = 0
+            r0.f3388b = r7
+            r0.f3391e = r3
+            kotlinx.coroutines.MainCoroutineDispatcher r2 = kotlinx.coroutines.Dispatchers.getMain()
+            kotlinx.coroutines.MainCoroutineDispatcher r2 = r2.getImmediate()
+            androidx.lifecycle.k r3 = new androidx.lifecycle.k
+            r3.<init>(r5, r6, r7)
+            java.lang.Object r7 = kotlinx.coroutines.BuildersKt.withContext(r2, r3, r0)
+            if (r7 != r1) goto L69
+        L68:
+            return r1
+        L69:
+            androidx.lifecycle.r r7 = (androidx.lifecycle.r) r7
+            r5.f3393n = r7
+            return r7
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.lifecycle.C0189j.m(androidx.lifecycle.j, kotlin.coroutines.jvm.internal.ContinuationImpl):java.lang.Object");
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C0190k.java

@@ -0,0 +1,59 @@
+package androidx.lifecycle;
+
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+/* renamed from: androidx.lifecycle.k, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0190k extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ C0189j f3394a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ Q f3395b;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public C0190k(C0189j c0189j, Q q4, Continuation continuation) {
+        super(2, continuation);
+        this.f3394a = c0189j;
+        this.f3395b = q4;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new C0190k(this.f3394a, this.f3395b, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((C0190k) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        ResultKt.throwOnFailure(obj);
+        C0189j c0189j = this.f3394a;
+        C0191l c0191l = new C0191l(new I1.b(c0189j, 4));
+        c0189j.getClass();
+        Q q4 = this.f3395b;
+        if (q4 == null) {
+            throw new NullPointerException("source cannot be null");
+        }
+        V v3 = new V(q4, c0191l);
+        V v4 = (V) c0189j.f3331l.b(q4, v3);
+        if (v4 != null && v4.f3329b != c0191l) {
+            throw new IllegalArgumentException("This source was already added with the different observer");
+        }
+        if (v4 == null && c0189j.f3314c > 0) {
+            q4.f(v3);
+        }
+        return new r(q4, c0189j);
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C0191l.java

@@ -0,0 +1,158 @@
+package androidx.lifecycle;
+
+import kotlin.Function;
+import kotlin.jvm.internal.FunctionAdapter;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+
+/* renamed from: androidx.lifecycle.l, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final /* synthetic */ class C0191l implements Y, FunctionAdapter {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f3397a = 0;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ Lambda f3398b;
+
+    public C0191l(I1.b function) {
+        Intrinsics.checkNotNullParameter(function, "function");
+        this.f3398b = function;
+    }
+
+    public final boolean equals(Object obj) {
+        switch (this.f3397a) {
+            case 0:
+                if (!(obj instanceof Y) || !(obj instanceof FunctionAdapter)) {
+                    return false;
+                }
+                return Intrinsics.areEqual((I1.b) this.f3398b, ((FunctionAdapter) obj).getFunctionDelegate());
+            case 1:
+                if (!(obj instanceof Y) || !(obj instanceof FunctionAdapter)) {
+                    return false;
+                }
+                return Intrinsics.areEqual((b1.e) this.f3398b, ((FunctionAdapter) obj).getFunctionDelegate());
+            case 2:
+                if (!(obj instanceof Y) || !(obj instanceof FunctionAdapter)) {
+                    return false;
+                }
+                return Intrinsics.areEqual((com.adif.elcanomovil.uiStations.main.a) this.f3398b, ((FunctionAdapter) obj).getFunctionDelegate());
+            case 3:
+                if (!(obj instanceof Y) || !(obj instanceof FunctionAdapter)) {
+                    return false;
+                }
+                return Intrinsics.areEqual((com.adif.elcanomovil.uiStations.main.b) this.f3398b, ((FunctionAdapter) obj).getFunctionDelegate());
+            case 4:
+                if (!(obj instanceof Y) || !(obj instanceof FunctionAdapter)) {
+                    return false;
+                }
+                return Intrinsics.areEqual((com.adif.elcanomovil.uiStations.main.f) this.f3398b, ((FunctionAdapter) obj).getFunctionDelegate());
+            case 5:
+                if (!(obj instanceof Y) || !(obj instanceof FunctionAdapter)) {
+                    return false;
+                }
+                return Intrinsics.areEqual((com.adif.elcanomovil.uiSubscriptions.home.c) this.f3398b, ((FunctionAdapter) obj).getFunctionDelegate());
+            default:
+                if (!(obj instanceof Y) || !(obj instanceof FunctionAdapter)) {
+                    return false;
+                }
+                return Intrinsics.areEqual((T0.j) this.f3398b, ((FunctionAdapter) obj).getFunctionDelegate());
+        }
+    }
+
+    @Override // kotlin.jvm.internal.FunctionAdapter
+    public final Function getFunctionDelegate() {
+        switch (this.f3397a) {
+            case 0:
+                return (I1.b) this.f3398b;
+            case 1:
+                return (b1.e) this.f3398b;
+            case 2:
+                return (com.adif.elcanomovil.uiStations.main.a) this.f3398b;
+            case 3:
+                return (com.adif.elcanomovil.uiStations.main.b) this.f3398b;
+            case 4:
+                return (com.adif.elcanomovil.uiStations.main.f) this.f3398b;
+            case 5:
+                return (com.adif.elcanomovil.uiSubscriptions.home.c) this.f3398b;
+            default:
+                return (T0.j) this.f3398b;
+        }
+    }
+
+    public final int hashCode() {
+        switch (this.f3397a) {
+            case 0:
+                return ((I1.b) this.f3398b).hashCode();
+            case 1:
+                return ((b1.e) this.f3398b).hashCode();
+            case 2:
+                return ((com.adif.elcanomovil.uiStations.main.a) this.f3398b).hashCode();
+            case 3:
+                return ((com.adif.elcanomovil.uiStations.main.b) this.f3398b).hashCode();
+            case 4:
+                return ((com.adif.elcanomovil.uiStations.main.f) this.f3398b).hashCode();
+            case 5:
+                return ((com.adif.elcanomovil.uiSubscriptions.home.c) this.f3398b).hashCode();
+            default:
+                return ((T0.j) this.f3398b).hashCode();
+        }
+    }
+
+    @Override // androidx.lifecycle.Y
+    public final /* synthetic */ void onChanged(Object obj) {
+        switch (this.f3397a) {
+            case 0:
+                ((I1.b) this.f3398b).invoke(obj);
+                return;
+            case 1:
+                ((b1.e) this.f3398b).invoke(obj);
+                return;
+            case 2:
+                ((com.adif.elcanomovil.uiStations.main.a) this.f3398b).invoke(obj);
+                return;
+            case 3:
+                ((com.adif.elcanomovil.uiStations.main.b) this.f3398b).invoke(obj);
+                return;
+            case 4:
+                ((com.adif.elcanomovil.uiStations.main.f) this.f3398b).invoke(obj);
+                return;
+            case 5:
+                ((com.adif.elcanomovil.uiSubscriptions.home.c) this.f3398b).invoke(obj);
+                return;
+            default:
+                ((T0.j) this.f3398b).invoke(obj);
+                return;
+        }
+    }
+
+    public C0191l(T0.j function) {
+        Intrinsics.checkNotNullParameter(function, "function");
+        this.f3398b = function;
+    }
+
+    public C0191l(b1.e function) {
+        Intrinsics.checkNotNullParameter(function, "function");
+        this.f3398b = function;
+    }
+
+    public C0191l(com.adif.elcanomovil.uiStations.main.a function) {
+        Intrinsics.checkNotNullParameter(function, "function");
+        this.f3398b = function;
+    }
+
+    public C0191l(com.adif.elcanomovil.uiStations.main.b function) {
+        Intrinsics.checkNotNullParameter(function, "function");
+        this.f3398b = function;
+    }
+
+    public C0191l(com.adif.elcanomovil.uiStations.main.f function) {
+        Intrinsics.checkNotNullParameter(function, "function");
+        this.f3398b = function;
+    }
+
+    public C0191l(com.adif.elcanomovil.uiSubscriptions.home.c function) {
+        Intrinsics.checkNotNullParameter(function, "function");
+        this.f3398b = function;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C0194o.java

@@ -0,0 +1,129 @@
+package androidx.lifecycle;
+
+import android.os.Handler;
+import android.widget.FrameLayout;
+import java.util.HashMap;
+import java.util.List;
+import java.util.WeakHashMap;
+import kotlin.jvm.internal.Intrinsics;
+import v0.C0639d;
+
+/* renamed from: androidx.lifecycle.o, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0194o implements H {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f3409a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final Object f3410b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final Object f3411c;
+
+    public /* synthetic */ C0194o(int i, Object obj, Object obj2) {
+        this.f3409a = i;
+        this.f3410b = obj;
+        this.f3411c = obj2;
+    }
+
+    @Override // androidx.lifecycle.H
+    public final void onStateChanged(J owner, A event) {
+        Object obj = this.f3411c;
+        Object obj2 = this.f3410b;
+        switch (this.f3409a) {
+            case 0:
+                Intrinsics.checkNotNullParameter(owner, "source");
+                Intrinsics.checkNotNullParameter(event, "event");
+                InterfaceC0192m interfaceC0192m = (InterfaceC0192m) obj2;
+                switch (AbstractC0193n.$EnumSwitchMapping$0[event.ordinal()]) {
+                    case 1:
+                        interfaceC0192m.getClass();
+                        Intrinsics.checkNotNullParameter(owner, "owner");
+                        break;
+                    case 2:
+                        interfaceC0192m.x(owner);
+                        break;
+                    case 3:
+                        interfaceC0192m.d(owner);
+                        break;
+                    case 4:
+                        interfaceC0192m.getClass();
+                        Intrinsics.checkNotNullParameter(owner, "owner");
+                        break;
+                    case 5:
+                        interfaceC0192m.O(owner);
+                        break;
+                    case 6:
+                        interfaceC0192m.e(owner);
+                        break;
+                    case 7:
+                        throw new IllegalArgumentException("ON_ANY must not been send by anybody");
+                }
+                H h = (H) obj;
+                if (h != null) {
+                    h.onStateChanged(owner, event);
+                    return;
+                }
+                return;
+            case 1:
+                Intrinsics.checkNotNullParameter(owner, "source");
+                Intrinsics.checkNotNullParameter(event, "event");
+                if (event == A.ON_START) {
+                    ((C) obj2).c(this);
+                    ((C0639d) obj).d();
+                    return;
+                }
+                return;
+            case 2:
+                HashMap hashMap = ((C0184e) obj).f3353a;
+                I i = (I) obj2;
+                C0184e.a((List) hashMap.get(event), owner, event, i);
+                C0184e.a((List) hashMap.get(A.ON_ANY), owner, event, i);
+                return;
+            case 3:
+                androidx.viewpager2.adapter.f fVar = (androidx.viewpager2.adapter.f) obj;
+                if (fVar.shouldDelayFragmentTransactions()) {
+                    return;
+                }
+                owner.getLifecycle().c(this);
+                androidx.viewpager2.adapter.g gVar = (androidx.viewpager2.adapter.g) obj2;
+                FrameLayout frameLayout = (FrameLayout) gVar.itemView;
+                WeakHashMap weakHashMap = O.X.f1226a;
+                if (frameLayout.isAttachedToWindow()) {
+                    fVar.placeFragmentInViewHolder(gVar);
+                    return;
+                }
+                return;
+            default:
+                if (event == A.ON_DESTROY) {
+                    ((Handler) obj2).removeCallbacks((androidx.viewpager2.adapter.a) obj);
+                    owner.getLifecycle().c(this);
+                    return;
+                }
+                return;
+        }
+    }
+
+    public C0194o(InterfaceC0192m defaultLifecycleObserver, H h) {
+        this.f3409a = 0;
+        Intrinsics.checkNotNullParameter(defaultLifecycleObserver, "defaultLifecycleObserver");
+        this.f3410b = defaultLifecycleObserver;
+        this.f3411c = h;
+    }
+
+    public C0194o(I i) {
+        this.f3409a = 2;
+        this.f3410b = i;
+        C0186g c0186g = C0186g.f3369c;
+        Class<?> cls = i.getClass();
+        C0184e c0184e = (C0184e) c0186g.f3370a.get(cls);
+        this.f3411c = c0184e == null ? c0186g.a(cls, null) : c0184e;
+    }
+
+    public C0194o(androidx.viewpager2.adapter.f fVar, androidx.viewpager2.adapter.g gVar) {
+        this.f3409a = 3;
+        this.f3411c = fVar;
+        this.f3410b = gVar;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C0195p.java

@@ -0,0 +1,48 @@
+package androidx.lifecycle;
+
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+/* renamed from: androidx.lifecycle.p, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0195p extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ r f3415a;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public C0195p(r rVar, Continuation continuation) {
+        super(2, continuation);
+        this.f3415a = rVar;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new C0195p(this.f3415a, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((C0195p) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        ResultKt.throwOnFailure(obj);
+        r rVar = this.f3415a;
+        if (!rVar.f3423c) {
+            V v3 = (V) rVar.f3422b.f3331l.c(rVar.f3421a);
+            if (v3 != null) {
+                v3.f3328a.i(v3);
+            }
+            rVar.f3423c = true;
+        }
+        return Unit.INSTANCE;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C0196q.java

@@ -0,0 +1,48 @@
+package androidx.lifecycle;
+
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+/* renamed from: androidx.lifecycle.q, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0196q extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ r f3416a;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public C0196q(r rVar, Continuation continuation) {
+        super(2, continuation);
+        this.f3416a = rVar;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new C0196q(this.f3416a, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((C0196q) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        ResultKt.throwOnFailure(obj);
+        r rVar = this.f3416a;
+        if (!rVar.f3423c) {
+            V v3 = (V) rVar.f3422b.f3331l.c(rVar.f3421a);
+            if (v3 != null) {
+                v3.f3328a.i(v3);
+            }
+            rVar.f3423c = true;
+        }
+        return Unit.INSTANCE;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C0198t.java

@@ -0,0 +1,61 @@
+package androidx.lifecycle;
+
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.flow.Flow;
+
+/* renamed from: androidx.lifecycle.t, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0198t extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f3429a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public /* synthetic */ Object f3430b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ Flow f3431c;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public C0198t(Flow flow, Continuation continuation) {
+        super(2, continuation);
+        this.f3431c = flow;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        C0198t c0198t = new C0198t(this.f3431c, continuation);
+        c0198t.f3430b = obj;
+        return c0198t;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((C0198t) create((U) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f3429a;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            C1.b bVar = new C1.b((U) this.f3430b, 2);
+            this.f3429a = 1;
+            if (this.f3431c.collect(bVar, this) == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        return Unit.INSTANCE;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/C0201w.java

@@ -0,0 +1,8 @@
+package androidx.lifecycle;
+
+import v0.InterfaceC0637b;
+
+/* renamed from: androidx.lifecycle.w, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0201w implements InterfaceC0637b {
+}

apk_decompiled/sources/androidx/lifecycle/C0203y.java

@@ -0,0 +1,52 @@
+package androidx.lifecycle;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* renamed from: androidx.lifecycle.y, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0203y {
+    public static A a(B state) {
+        Intrinsics.checkNotNullParameter(state, "state");
+        int i = AbstractC0202x.$EnumSwitchMapping$0[state.ordinal()];
+        if (i == 1) {
+            return A.ON_DESTROY;
+        }
+        if (i == 2) {
+            return A.ON_STOP;
+        }
+        if (i != 3) {
+            return null;
+        }
+        return A.ON_PAUSE;
+    }
+
+    public static A b(B state) {
+        Intrinsics.checkNotNullParameter(state, "state");
+        int i = AbstractC0202x.$EnumSwitchMapping$0[state.ordinal()];
+        if (i == 1) {
+            return A.ON_START;
+        }
+        if (i == 2) {
+            return A.ON_RESUME;
+        }
+        if (i != 5) {
+            return null;
+        }
+        return A.ON_CREATE;
+    }
+
+    public static A c(B state) {
+        Intrinsics.checkNotNullParameter(state, "state");
+        int i = AbstractC0202x.$EnumSwitchMapping$0[state.ordinal()];
+        if (i == 1) {
+            return A.ON_CREATE;
+        }
+        if (i == 2) {
+            return A.ON_START;
+        }
+        if (i != 3) {
+            return null;
+        }
+        return A.ON_RESUME;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/D.java

@@ -0,0 +1,54 @@
+package androidx.lifecycle;
+
+import java.util.concurrent.CancellationException;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+import kotlinx.coroutines.JobKt__JobKt;
+
+/* loaded from: classes.dex */
+public final class D extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public /* synthetic */ Object f3289a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ E f3290b;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public D(E e4, Continuation continuation) {
+        super(2, continuation);
+        this.f3290b = e4;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        D d4 = new D(this.f3290b, continuation);
+        d4.f3289a = obj;
+        return d4;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((D) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        ResultKt.throwOnFailure(obj);
+        CoroutineScope coroutineScope = (CoroutineScope) this.f3289a;
+        E e4 = this.f3290b;
+        C c4 = e4.f3291a;
+        if (c4.b().compareTo(B.f3281b) >= 0) {
+            c4.a(e4);
+        } else {
+            JobKt__JobKt.cancel$default(coroutineScope.getCoroutineContext(), (CancellationException) null, 1, (Object) null);
+        }
+        return Unit.INSTANCE;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/D0.java

@@ -0,0 +1,6 @@
+package androidx.lifecycle;
+
+/* loaded from: classes.dex */
+public interface D0 {
+    C0 getViewModelStore();
+}

apk_decompiled/sources/androidx/lifecycle/E.java

@@ -0,0 +1,43 @@
+package androidx.lifecycle;
+
+import java.util.concurrent.CancellationException;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.CoroutineScope;
+import kotlinx.coroutines.JobKt__JobKt;
+
+/* loaded from: classes.dex */
+public final class E implements H, CoroutineScope {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final C f3291a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final CoroutineContext f3292b;
+
+    public E(C lifecycle, CoroutineContext coroutineContext) {
+        Intrinsics.checkNotNullParameter(lifecycle, "lifecycle");
+        Intrinsics.checkNotNullParameter(coroutineContext, "coroutineContext");
+        this.f3291a = lifecycle;
+        this.f3292b = coroutineContext;
+        if (lifecycle.b() == B.f3280a) {
+            JobKt__JobKt.cancel$default(coroutineContext, (CancellationException) null, 1, (Object) null);
+        }
+    }
+
+    @Override // kotlinx.coroutines.CoroutineScope
+    public final CoroutineContext getCoroutineContext() {
+        return this.f3292b;
+    }
+
+    @Override // androidx.lifecycle.H
+    public final void onStateChanged(J source, A event) {
+        Intrinsics.checkNotNullParameter(source, "source");
+        Intrinsics.checkNotNullParameter(event, "event");
+        C c4 = this.f3291a;
+        if (c4.b().compareTo(B.f3280a) <= 0) {
+            c4.c(this);
+            JobKt__JobKt.cancel$default(this.f3292b, (CancellationException) null, 1, (Object) null);
+        }
+    }
+}

apk_decompiled/sources/androidx/lifecycle/F.java

@@ -0,0 +1,15 @@
+package androidx.lifecycle;
+
+import android.app.Activity;
+import android.os.Bundle;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class F extends AbstractC0197s {
+    @Override // androidx.lifecycle.AbstractC0197s, android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityCreated(Activity activity, Bundle bundle) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+        int i = k0.f3396a;
+        i0.b(activity);
+    }
+}

apk_decompiled/sources/androidx/lifecycle/G.java

@@ -0,0 +1,10 @@
+package androidx.lifecycle;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/* loaded from: classes.dex */
+public abstract class G {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final AtomicBoolean f3293a = new AtomicBoolean(false);
+}

apk_decompiled/sources/androidx/lifecycle/H.java

@@ -0,0 +1,6 @@
+package androidx.lifecycle;
+
+/* loaded from: classes.dex */
+public interface H extends I {
+    void onStateChanged(J j4, A a2);
+}

apk_decompiled/sources/androidx/lifecycle/I.java

@@ -0,0 +1,5 @@
+package androidx.lifecycle;
+
+/* loaded from: classes.dex */
+public interface I {
+}

apk_decompiled/sources/androidx/lifecycle/InterfaceC0192m.java

@@ -0,0 +1,23 @@
+package androidx.lifecycle;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* renamed from: androidx.lifecycle.m, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public interface InterfaceC0192m extends I {
+    default void O(J owner) {
+        Intrinsics.checkNotNullParameter(owner, "owner");
+    }
+
+    default void d(J owner) {
+        Intrinsics.checkNotNullParameter(owner, "owner");
+    }
+
+    default void e(J owner) {
+        Intrinsics.checkNotNullParameter(owner, "owner");
+    }
+
+    default void x(J owner) {
+        Intrinsics.checkNotNullParameter(owner, "owner");
+    }
+}

apk_decompiled/sources/androidx/lifecycle/InterfaceC0199u.java

@@ -0,0 +1,6 @@
+package androidx.lifecycle;
+
+/* renamed from: androidx.lifecycle.u, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public interface InterfaceC0199u {
+}

apk_decompiled/sources/androidx/lifecycle/InterfaceC0200v.java

@@ -0,0 +1,9 @@
+package androidx.lifecycle;
+
+/* renamed from: androidx.lifecycle.v, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public interface InterfaceC0200v {
+    l0.c getDefaultViewModelCreationExtras();
+
+    y0 getDefaultViewModelProviderFactory();
+}

apk_decompiled/sources/androidx/lifecycle/J.java

@@ -0,0 +1,6 @@
+package androidx.lifecycle;
+
+/* loaded from: classes.dex */
+public interface J {
+    C getLifecycle();
+}

apk_decompiled/sources/androidx/lifecycle/K.java

@@ -0,0 +1,27 @@
+package androidx.lifecycle;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class K {
+
+    /* renamed from: a, reason: collision with root package name */
+    public B f3294a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public H f3295b;
+
+    public final void a(J j4, A event) {
+        Intrinsics.checkNotNullParameter(event, "event");
+        B a2 = event.a();
+        B state1 = this.f3294a;
+        Intrinsics.checkNotNullParameter(state1, "state1");
+        if (a2.compareTo(state1) < 0) {
+            state1 = a2;
+        }
+        this.f3294a = state1;
+        Intrinsics.checkNotNull(j4);
+        this.f3295b.onStateChanged(j4, event);
+        this.f3294a = a2;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/L.java

@@ -0,0 +1,218 @@
+package androidx.lifecycle;
+
+import java.lang.ref.WeakReference;
+import java.lang.reflect.Constructor;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.flow.MutableStateFlow;
+import kotlinx.coroutines.flow.StateFlowKt;
+import n.C0508b;
+import o.C0515a;
+import o.C0517c;
+import v0.C0636a;
+
+/* loaded from: classes.dex */
+public final class L extends C {
+
+    /* renamed from: b, reason: collision with root package name */
+    public final boolean f3296b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public C0515a f3297c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public B f3298d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final WeakReference f3299e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public int f3300f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public boolean f3301g;
+    public boolean h;
+    public final ArrayList i;
+
+    /* renamed from: j, reason: collision with root package name */
+    public final MutableStateFlow f3302j;
+
+    public L(J provider) {
+        Intrinsics.checkNotNullParameter(provider, "provider");
+        this.f3296b = true;
+        this.f3297c = new C0515a();
+        B b4 = B.f3281b;
+        this.f3298d = b4;
+        this.i = new ArrayList();
+        this.f3299e = new WeakReference(provider);
+        this.f3302j = StateFlowKt.MutableStateFlow(b4);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r2v3, types: [java.lang.Object, androidx.lifecycle.K] */
+    @Override // androidx.lifecycle.C
+    public final void a(I object) {
+        H h;
+        J j4;
+        ArrayList arrayList = this.i;
+        Intrinsics.checkNotNullParameter(object, "observer");
+        e("addObserver");
+        B b4 = this.f3298d;
+        B initialState = B.f3280a;
+        if (b4 != initialState) {
+            initialState = B.f3281b;
+        }
+        Intrinsics.checkNotNullParameter(initialState, "initialState");
+        ?? obj = new Object();
+        Intrinsics.checkNotNull(object);
+        HashMap hashMap = M.f3303a;
+        Intrinsics.checkNotNullParameter(object, "object");
+        boolean z3 = object instanceof H;
+        boolean z4 = object instanceof InterfaceC0192m;
+        if (z3 && z4) {
+            h = new C0194o((InterfaceC0192m) object, (H) object);
+        } else if (z4) {
+            h = new C0194o((InterfaceC0192m) object, (H) null);
+        } else if (z3) {
+            h = (H) object;
+        } else {
+            Class<?> cls = object.getClass();
+            if (M.c(cls) == 2) {
+                Object obj2 = M.f3304b.get(cls);
+                Intrinsics.checkNotNull(obj2);
+                List list = (List) obj2;
+                if (list.size() == 1) {
+                    M.a((Constructor) list.get(0), object);
+                    Intrinsics.checkNotNullParameter(null, "generatedAdapter");
+                    h = new Object();
+                } else {
+                    int size = list.size();
+                    InterfaceC0199u[] interfaceC0199uArr = new InterfaceC0199u[size];
+                    for (int i = 0; i < size; i++) {
+                        M.a((Constructor) list.get(i), object);
+                        interfaceC0199uArr[i] = null;
+                    }
+                    h = new C0636a(interfaceC0199uArr);
+                }
+            } else {
+                h = new C0194o(object);
+            }
+        }
+        obj.f3295b = h;
+        obj.f3294a = initialState;
+        if (((K) this.f3297c.b(object, obj)) == null && (j4 = (J) this.f3299e.get()) != null) {
+            boolean z5 = this.f3300f != 0 || this.f3301g;
+            B d4 = d(object);
+            this.f3300f++;
+            while (obj.f3294a.compareTo(d4) < 0 && this.f3297c.f7883e.containsKey(object)) {
+                arrayList.add(obj.f3294a);
+                C0203y c0203y = A.Companion;
+                B b5 = obj.f3294a;
+                c0203y.getClass();
+                A b6 = C0203y.b(b5);
+                if (b6 == null) {
+                    throw new IllegalStateException("no event up from " + obj.f3294a);
+                }
+                obj.a(j4, b6);
+                arrayList.remove(arrayList.size() - 1);
+                d4 = d(object);
+            }
+            if (!z5) {
+                i();
+            }
+            this.f3300f--;
+        }
+    }
+
+    @Override // androidx.lifecycle.C
+    public final B b() {
+        return this.f3298d;
+    }
+
+    @Override // androidx.lifecycle.C
+    public final void c(I observer) {
+        Intrinsics.checkNotNullParameter(observer, "observer");
+        e("removeObserver");
+        this.f3297c.c(observer);
+    }
+
+    public final B d(I i) {
+        K k4;
+        HashMap hashMap = this.f3297c.f7883e;
+        C0517c c0517c = hashMap.containsKey(i) ? ((C0517c) hashMap.get(i)).f7890d : null;
+        B state1 = (c0517c == null || (k4 = (K) c0517c.f7888b) == null) ? null : k4.f3294a;
+        ArrayList arrayList = this.i;
+        B b4 = arrayList.isEmpty() ? null : (B) arrayList.get(arrayList.size() - 1);
+        B state12 = this.f3298d;
+        Intrinsics.checkNotNullParameter(state12, "state1");
+        if (state1 == null || state1.compareTo(state12) >= 0) {
+            state1 = state12;
+        }
+        Intrinsics.checkNotNullParameter(state1, "state1");
+        return (b4 == null || b4.compareTo(state1) >= 0) ? state1 : b4;
+    }
+
+    public final void e(String str) {
+        if (this.f3296b && !C0508b.L().M()) {
+            throw new IllegalStateException(C.w.o("Method ", str, " must be called on the main thread").toString());
+        }
+    }
+
+    public final void f(A event) {
+        Intrinsics.checkNotNullParameter(event, "event");
+        e("handleLifecycleEvent");
+        g(event.a());
+    }
+
+    public final void g(B b4) {
+        B b5 = this.f3298d;
+        if (b5 == b4) {
+            return;
+        }
+        B b6 = B.f3281b;
+        B b7 = B.f3280a;
+        if (b5 == b6 && b4 == b7) {
+            throw new IllegalStateException(("State must be at least CREATED to move to " + b4 + ", but was " + this.f3298d + " in component " + this.f3299e.get()).toString());
+        }
+        this.f3298d = b4;
+        if (this.f3301g || this.f3300f != 0) {
+            this.h = true;
+            return;
+        }
+        this.f3301g = true;
+        i();
+        this.f3301g = false;
+        if (this.f3298d == b7) {
+            this.f3297c = new C0515a();
+        }
+    }
+
+    public final void h(B state) {
+        Intrinsics.checkNotNullParameter(state, "state");
+        e("setCurrentState");
+        g(state);
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:10:0x0030, code lost:
+    
+        r7.h = false;
+        r7.f3302j.setValue(r7.f3298d);
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:11:0x0039, code lost:
+    
+        return;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final void i() {
+        /*
+            Method dump skipped, instructions count: 384
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.lifecycle.L.i():void");
+    }
+}

apk_decompiled/sources/androidx/lifecycle/M.java

@@ -0,0 +1,158 @@
+package androidx.lifecycle;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import kotlin.collections.CollectionsKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.StringsKt__StringsJVMKt;
+
+/* loaded from: classes.dex */
+public abstract class M {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final HashMap f3303a = new HashMap();
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final HashMap f3304b = new HashMap();
+
+    public static void a(Constructor constructor, I i) {
+        try {
+            Object newInstance = constructor.newInstance(i);
+            Intrinsics.checkNotNullExpressionValue(newInstance, "{\n            constructo…tance(`object`)\n        }");
+            if (newInstance == null) {
+            } else {
+                throw new ClassCastException();
+            }
+        } catch (IllegalAccessException e4) {
+            throw new RuntimeException(e4);
+        } catch (InstantiationException e5) {
+            throw new RuntimeException(e5);
+        } catch (InvocationTargetException e6) {
+            throw new RuntimeException(e6);
+        }
+    }
+
+    public static final String b(String className) {
+        String replace$default;
+        Intrinsics.checkNotNullParameter(className, "className");
+        StringBuilder sb = new StringBuilder();
+        replace$default = StringsKt__StringsJVMKt.replace$default(className, ".", "_", false, 4, (Object) null);
+        sb.append(replace$default);
+        sb.append("_LifecycleAdapter");
+        return sb.toString();
+    }
+
+    public static int c(Class cls) {
+        Constructor<?> constructor;
+        boolean z3;
+        HashMap hashMap = f3303a;
+        Integer num = (Integer) hashMap.get(cls);
+        if (num != null) {
+            return num.intValue();
+        }
+        int i = 1;
+        if (cls.getCanonicalName() != null) {
+            ArrayList arrayList = null;
+            try {
+                Package r32 = cls.getPackage();
+                String name = cls.getCanonicalName();
+                String fullPackage = r32 != null ? r32.getName() : "";
+                Intrinsics.checkNotNullExpressionValue(fullPackage, "fullPackage");
+                if (fullPackage.length() != 0) {
+                    Intrinsics.checkNotNullExpressionValue(name, "name");
+                    name = name.substring(fullPackage.length() + 1);
+                    Intrinsics.checkNotNullExpressionValue(name, "this as java.lang.String).substring(startIndex)");
+                }
+                Intrinsics.checkNotNullExpressionValue(name, "if (fullPackage.isEmpty(…g(fullPackage.length + 1)");
+                String b4 = b(name);
+                if (fullPackage.length() != 0) {
+                    b4 = fullPackage + '.' + b4;
+                }
+                Class<?> cls2 = Class.forName(b4);
+                Intrinsics.checkNotNull(cls2, "null cannot be cast to non-null type java.lang.Class<out androidx.lifecycle.GeneratedAdapter>");
+                constructor = cls2.getDeclaredConstructor(cls);
+                if (!constructor.isAccessible()) {
+                    constructor.setAccessible(true);
+                }
+            } catch (ClassNotFoundException unused) {
+                constructor = null;
+            } catch (NoSuchMethodException e4) {
+                throw new RuntimeException(e4);
+            }
+            HashMap hashMap2 = f3304b;
+            if (constructor != null) {
+                hashMap2.put(cls, CollectionsKt.listOf(constructor));
+            } else {
+                C0186g c0186g = C0186g.f3369c;
+                HashMap hashMap3 = c0186g.f3371b;
+                Boolean bool = (Boolean) hashMap3.get(cls);
+                if (bool != null) {
+                    z3 = bool.booleanValue();
+                } else {
+                    try {
+                        Method[] declaredMethods = cls.getDeclaredMethods();
+                        int length = declaredMethods.length;
+                        int i4 = 0;
+                        while (true) {
+                            if (i4 >= length) {
+                                hashMap3.put(cls, Boolean.FALSE);
+                                z3 = false;
+                                break;
+                            }
+                            if (((Z) declaredMethods[i4].getAnnotation(Z.class)) != null) {
+                                c0186g.a(cls, declaredMethods);
+                                z3 = true;
+                                break;
+                            }
+                            i4++;
+                        }
+                    } catch (NoClassDefFoundError e5) {
+                        throw new IllegalArgumentException("The observer class has some methods that use newer APIs which are not available in the current OS version. Lifecycles cannot access even other methods so you should make sure that your observer classes only access framework classes that are available in your min API level OR use lifecycle:compiler annotation processor.", e5);
+                    }
+                }
+                if (!z3) {
+                    Class superclass = cls.getSuperclass();
+                    if (superclass != null && I.class.isAssignableFrom(superclass)) {
+                        Intrinsics.checkNotNullExpressionValue(superclass, "superclass");
+                        if (c(superclass) != 1) {
+                            Object obj = hashMap2.get(superclass);
+                            Intrinsics.checkNotNull(obj);
+                            arrayList = new ArrayList((Collection) obj);
+                        }
+                    }
+                    Class<?>[] interfaces = cls.getInterfaces();
+                    Intrinsics.checkNotNullExpressionValue(interfaces, "klass.interfaces");
+                    int length2 = interfaces.length;
+                    int i5 = 0;
+                    while (true) {
+                        if (i5 < length2) {
+                            Class<?> intrface = interfaces[i5];
+                            if (intrface != null && I.class.isAssignableFrom(intrface)) {
+                                Intrinsics.checkNotNullExpressionValue(intrface, "intrface");
+                                if (c(intrface) == 1) {
+                                    break;
+                                }
+                                if (arrayList == null) {
+                                    arrayList = new ArrayList();
+                                }
+                                Object obj2 = hashMap2.get(intrface);
+                                Intrinsics.checkNotNull(obj2);
+                                arrayList.addAll((Collection) obj2);
+                            }
+                            i5++;
+                        } else if (arrayList != null) {
+                            hashMap2.put(cls, arrayList);
+                        }
+                    }
+                }
+            }
+            i = 2;
+        }
+        hashMap.put(cls, Integer.valueOf(i));
+        return i;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/N.java

@@ -0,0 +1,9 @@
+package androidx.lifecycle;
+
+/* loaded from: classes.dex */
+public final class N extends P {
+    @Override // androidx.lifecycle.P
+    public final boolean f() {
+        return true;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/O.java

@@ -0,0 +1,49 @@
+package androidx.lifecycle;
+
+/* loaded from: classes.dex */
+public final class O extends P implements H {
+
+    /* renamed from: e, reason: collision with root package name */
+    public final J f3305e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final /* synthetic */ Q f3306f;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public O(Q q4, J j4, Y y3) {
+        super(q4, y3);
+        this.f3306f = q4;
+        this.f3305e = j4;
+    }
+
+    @Override // androidx.lifecycle.P
+    public final void b() {
+        this.f3305e.getLifecycle().c(this);
+    }
+
+    @Override // androidx.lifecycle.P
+    public final boolean c(J j4) {
+        return this.f3305e == j4;
+    }
+
+    @Override // androidx.lifecycle.P
+    public final boolean f() {
+        return this.f3305e.getLifecycle().b().a(B.f3283d);
+    }
+
+    @Override // androidx.lifecycle.H
+    public final void onStateChanged(J j4, A a2) {
+        J j5 = this.f3305e;
+        B b4 = j5.getLifecycle().b();
+        if (b4 == B.f3280a) {
+            this.f3306f.i(this.f3307a);
+            return;
+        }
+        B b5 = null;
+        while (b5 != b4) {
+            a(f());
+            b5 = b4;
+            b4 = j5.getLifecycle().b();
+        }
+    }
+}

apk_decompiled/sources/androidx/lifecycle/P.java

@@ -0,0 +1,68 @@
+package androidx.lifecycle;
+
+/* loaded from: classes.dex */
+public abstract class P {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Y f3307a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public boolean f3308b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public int f3309c = -1;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ Q f3310d;
+
+    public P(Q q4, Y y3) {
+        this.f3310d = q4;
+        this.f3307a = y3;
+    }
+
+    public final void a(boolean z3) {
+        if (z3 == this.f3308b) {
+            return;
+        }
+        this.f3308b = z3;
+        int i = z3 ? 1 : -1;
+        Q q4 = this.f3310d;
+        int i4 = q4.f3314c;
+        q4.f3314c = i + i4;
+        if (!q4.f3315d) {
+            q4.f3315d = true;
+            while (true) {
+                try {
+                    int i5 = q4.f3314c;
+                    if (i4 == i5) {
+                        break;
+                    }
+                    boolean z4 = i4 == 0 && i5 > 0;
+                    boolean z5 = i4 > 0 && i5 == 0;
+                    if (z4) {
+                        q4.g();
+                    } else if (z5) {
+                        q4.h();
+                    }
+                    i4 = i5;
+                } catch (Throwable th) {
+                    q4.f3315d = false;
+                    throw th;
+                }
+            }
+            q4.f3315d = false;
+        }
+        if (this.f3308b) {
+            q4.c(this);
+        }
+    }
+
+    public void b() {
+    }
+
+    public boolean c(J j4) {
+        return false;
+    }
+
+    public abstract boolean f();
+}

apk_decompiled/sources/androidx/lifecycle/ProcessLifecycleInitializer.java

@@ -0,0 +1,49 @@
+package androidx.lifecycle;
+
+import android.app.Application;
+import android.content.Context;
+import android.os.Handler;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import kotlin.Metadata;
+import kotlin.collections.CollectionsKt;
+import kotlin.jvm.internal.Intrinsics;
+import z0.C0665a;
+import z0.InterfaceC0666b;
+
+@Metadata(d1 = {"\u0000\u0010\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\b\u0003\u0018\u00002\b\u0012\u0004\u0012\u00020\u00020\u0001B\u0007¢\u0006\u0004\b\u0003\u0010\u0004¨\u0006\u0005"}, d2 = {"Landroidx/lifecycle/ProcessLifecycleInitializer;", "Lz0/b;", "Landroidx/lifecycle/J;", "<init>", "()V", "lifecycle-process_release"}, k = 1, mv = {1, 8, 0}, xi = 48)
+/* loaded from: classes.dex */
+public final class ProcessLifecycleInitializer implements InterfaceC0666b {
+    @Override // z0.InterfaceC0666b
+    public final Object a(Context context) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        C0665a c4 = C0665a.c(context);
+        Intrinsics.checkNotNullExpressionValue(c4, "getInstance(context)");
+        if (!c4.f9002b.contains(ProcessLifecycleInitializer.class)) {
+            throw new IllegalStateException("ProcessLifecycleInitializer cannot be initialized lazily.\n               Please ensure that you have:\n               <meta-data\n                   android:name='androidx.lifecycle.ProcessLifecycleInitializer'\n                   android:value='androidx.startup' />\n               under InitializationProvider in your AndroidManifest.xml");
+        }
+        AtomicBoolean atomicBoolean = G.f3293a;
+        Intrinsics.checkNotNullParameter(context, "context");
+        if (!G.f3293a.getAndSet(true)) {
+            Context applicationContext = context.getApplicationContext();
+            Intrinsics.checkNotNull(applicationContext, "null cannot be cast to non-null type android.app.Application");
+            ((Application) applicationContext).registerActivityLifecycleCallbacks(new F());
+        }
+        C0181c0 c0181c0 = C0181c0.h;
+        Intrinsics.checkNotNullParameter(context, "context");
+        C0181c0 c0181c02 = C0181c0.h;
+        c0181c02.getClass();
+        Intrinsics.checkNotNullParameter(context, "context");
+        c0181c02.f3341e = new Handler();
+        c0181c02.f3342f.f(A.ON_CREATE);
+        Context applicationContext2 = context.getApplicationContext();
+        Intrinsics.checkNotNull(applicationContext2, "null cannot be cast to non-null type android.app.Application");
+        ((Application) applicationContext2).registerActivityLifecycleCallbacks(new C0179b0(c0181c02));
+        return c0181c02;
+    }
+
+    @Override // z0.InterfaceC0666b
+    public final List dependencies() {
+        return CollectionsKt.emptyList();
+    }
+}

apk_decompiled/sources/androidx/lifecycle/Q.java

@@ -0,0 +1,164 @@
+package androidx.lifecycle;
+
+import java.util.Map;
+import n.C0508b;
+import o.C0518d;
+import o.C0520f;
+
+/* loaded from: classes.dex */
+public abstract class Q {
+
+    /* renamed from: k, reason: collision with root package name */
+    public static final Object f3311k = new Object();
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Object f3312a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final C0520f f3313b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public int f3314c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public boolean f3315d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public volatile Object f3316e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public volatile Object f3317f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public int f3318g;
+    public boolean h;
+    public boolean i;
+
+    /* renamed from: j, reason: collision with root package name */
+    public final F0.c f3319j;
+
+    public Q(Object obj) {
+        this.f3312a = new Object();
+        this.f3313b = new C0520f();
+        this.f3314c = 0;
+        this.f3317f = f3311k;
+        this.f3319j = new F0.c(this, 5);
+        this.f3316e = obj;
+        this.f3318g = 0;
+    }
+
+    public static void a(String str) {
+        if (!C0508b.L().M()) {
+            throw new IllegalStateException(C.w.o("Cannot invoke ", str, " on a background thread"));
+        }
+    }
+
+    public final void b(P p) {
+        if (p.f3308b) {
+            if (!p.f()) {
+                p.a(false);
+                return;
+            }
+            int i = p.f3309c;
+            int i4 = this.f3318g;
+            if (i >= i4) {
+                return;
+            }
+            p.f3309c = i4;
+            p.f3307a.onChanged(this.f3316e);
+        }
+    }
+
+    public final void c(P p) {
+        if (this.h) {
+            this.i = true;
+            return;
+        }
+        this.h = true;
+        do {
+            this.i = false;
+            if (p != null) {
+                b(p);
+                p = null;
+            } else {
+                C0520f c0520f = this.f3313b;
+                c0520f.getClass();
+                C0518d c0518d = new C0518d(c0520f);
+                c0520f.f7896c.put(c0518d, Boolean.FALSE);
+                while (c0518d.hasNext()) {
+                    b((P) ((Map.Entry) c0518d.next()).getValue());
+                    if (this.i) {
+                        break;
+                    }
+                }
+            }
+        } while (this.i);
+        this.h = false;
+    }
+
+    public final Object d() {
+        Object obj = this.f3316e;
+        if (obj != f3311k) {
+            return obj;
+        }
+        return null;
+    }
+
+    public final void e(J j4, Y y3) {
+        a("observe");
+        if (j4.getLifecycle().b() == B.f3280a) {
+            return;
+        }
+        O o4 = new O(this, j4, y3);
+        P p = (P) this.f3313b.b(y3, o4);
+        if (p != null && !p.c(j4)) {
+            throw new IllegalArgumentException("Cannot add the same observer with different lifecycles");
+        }
+        if (p != null) {
+            return;
+        }
+        j4.getLifecycle().a(o4);
+    }
+
+    public final void f(Y y3) {
+        a("observeForever");
+        P p = new P(this, y3);
+        P p3 = (P) this.f3313b.b(y3, p);
+        if (p3 instanceof O) {
+            throw new IllegalArgumentException("Cannot add the same observer with different lifecycles");
+        }
+        if (p3 != null) {
+            return;
+        }
+        p.a(true);
+    }
+
+    public void g() {
+    }
+
+    public void h() {
+    }
+
+    public final void i(Y y3) {
+        a("removeObserver");
+        P p = (P) this.f3313b.c(y3);
+        if (p == null) {
+            return;
+        }
+        p.b();
+        p.a(false);
+    }
+
+    public abstract void j(Object obj);
+
+    public Q() {
+        this.f3312a = new Object();
+        this.f3313b = new C0520f();
+        this.f3314c = 0;
+        Object obj = f3311k;
+        this.f3317f = obj;
+        this.f3319j = new F0.c(this, 5);
+        this.f3316e = obj;
+        this.f3318g = -1;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/S.java

@@ -0,0 +1,61 @@
+package androidx.lifecycle;
+
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+/* loaded from: classes.dex */
+public final class S extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f3320a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ U f3321b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ Object f3322c;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public S(U u3, Object obj, Continuation continuation) {
+        super(2, continuation);
+        this.f3321b = u3;
+        this.f3322c = obj;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new S(this.f3321b, this.f3322c, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((S) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f3320a;
+        U u3 = this.f3321b;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            C0189j c0189j = u3.f3326a;
+            this.f3320a = 1;
+            if (c0189j.l(this) == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        u3.f3326a.j(this.f3322c);
+        return Unit.INSTANCE;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/T.java

@@ -0,0 +1,57 @@
+package androidx.lifecycle;
+
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+/* loaded from: classes.dex */
+public final class T extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f3323a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ U f3324b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ C0189j f3325c;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public T(U u3, C0189j c0189j, Continuation continuation) {
+        super(2, continuation);
+        this.f3324b = u3;
+        this.f3325c = c0189j;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new T(this.f3324b, this.f3325c, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((T) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f3323a;
+        if (i != 0) {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+            return obj;
+        }
+        ResultKt.throwOnFailure(obj);
+        C0189j c0189j = this.f3324b.f3326a;
+        this.f3323a = 1;
+        Object m4 = c0189j.m(this.f3325c, this);
+        return m4 == coroutine_suspended ? coroutine_suspended : m4;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/U.java

@@ -0,0 +1,22 @@
+package androidx.lifecycle;
+
+import kotlin.coroutines.CoroutineContext;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.Dispatchers;
+
+/* loaded from: classes.dex */
+public final class U {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final C0189j f3326a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final CoroutineContext f3327b;
+
+    public U(C0189j target, CoroutineContext context) {
+        Intrinsics.checkNotNullParameter(target, "target");
+        Intrinsics.checkNotNullParameter(context, "context");
+        this.f3326a = target;
+        this.f3327b = context.plus(Dispatchers.getMain().getImmediate());
+    }
+}

apk_decompiled/sources/androidx/lifecycle/V.java

@@ -0,0 +1,29 @@
+package androidx.lifecycle;
+
+/* loaded from: classes.dex */
+public final class V implements Y {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Q f3328a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final C0191l f3329b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public int f3330c = -1;
+
+    public V(Q q4, C0191l c0191l) {
+        this.f3328a = q4;
+        this.f3329b = c0191l;
+    }
+
+    @Override // androidx.lifecycle.Y
+    public final void onChanged(Object obj) {
+        int i = this.f3330c;
+        int i4 = this.f3328a.f3318g;
+        if (i != i4) {
+            this.f3330c = i4;
+            this.f3329b.onChanged(obj);
+        }
+    }
+}

apk_decompiled/sources/androidx/lifecycle/W.java

@@ -0,0 +1,39 @@
+package androidx.lifecycle;
+
+import java.util.Iterator;
+import java.util.Map;
+import o.C0516b;
+import o.C0520f;
+
+/* loaded from: classes.dex */
+public class W extends X {
+
+    /* renamed from: l, reason: collision with root package name */
+    public final C0520f f3331l = new C0520f();
+
+    @Override // androidx.lifecycle.Q
+    public void g() {
+        Iterator it = this.f3331l.iterator();
+        while (true) {
+            C0516b c0516b = (C0516b) it;
+            if (!c0516b.hasNext()) {
+                return;
+            }
+            V v3 = (V) ((Map.Entry) c0516b.next()).getValue();
+            v3.f3328a.f(v3);
+        }
+    }
+
+    @Override // androidx.lifecycle.Q
+    public void h() {
+        Iterator it = this.f3331l.iterator();
+        while (true) {
+            C0516b c0516b = (C0516b) it;
+            if (!c0516b.hasNext()) {
+                return;
+            }
+            V v3 = (V) ((Map.Entry) c0516b.next()).getValue();
+            v3.f3328a.i(v3);
+        }
+    }
+}

apk_decompiled/sources/androidx/lifecycle/X.java

@@ -0,0 +1,41 @@
+package androidx.lifecycle;
+
+import android.os.Handler;
+import android.os.Looper;
+import n.C0508b;
+import n.C0510d;
+
+/* loaded from: classes.dex */
+public class X extends Q {
+    @Override // androidx.lifecycle.Q
+    public void j(Object obj) {
+        Q.a("setValue");
+        this.f3318g++;
+        this.f3316e = obj;
+        c(null);
+    }
+
+    public final void k(Object obj) {
+        boolean z3;
+        synchronized (this.f3312a) {
+            z3 = this.f3317f == Q.f3311k;
+            this.f3317f = obj;
+        }
+        if (z3) {
+            C0508b L3 = C0508b.L();
+            F0.c cVar = this.f3319j;
+            C0510d c0510d = L3.f7834a;
+            if (c0510d.f7838c == null) {
+                synchronized (c0510d.f7836a) {
+                    try {
+                        if (c0510d.f7838c == null) {
+                            c0510d.f7838c = Handler.createAsync(Looper.getMainLooper());
+                        }
+                    } finally {
+                    }
+                }
+            }
+            c0510d.f7838c.post(cVar);
+        }
+    }
+}

apk_decompiled/sources/androidx/lifecycle/Y.java

@@ -0,0 +1,6 @@
+package androidx.lifecycle;
+
+/* loaded from: classes.dex */
+public interface Y {
+    void onChanged(Object obj);
+}

apk_decompiled/sources/androidx/lifecycle/Z.java

@@ -0,0 +1,10 @@
+package androidx.lifecycle;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes.dex */
+public @interface Z {
+    A value();
+}

apk_decompiled/sources/androidx/lifecycle/e0.java

@@ -0,0 +1,127 @@
+package androidx.lifecycle;
+
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+import kotlinx.coroutines.sync.Mutex;
+
+/* loaded from: classes.dex */
+public final class e0 extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public Mutex f3355a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public SuspendLambda f3356b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public int f3357c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ Mutex f3358d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ SuspendLambda f3359e;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    /* JADX WARN: Multi-variable type inference failed */
+    public e0(Mutex mutex, Function2 function2, Continuation continuation) {
+        super(2, continuation);
+        this.f3358d = mutex;
+        this.f3359e = (SuspendLambda) function2;
+    }
+
+    /* JADX WARN: Type inference failed for: r0v0, types: [kotlin.coroutines.jvm.internal.SuspendLambda, kotlin.jvm.functions.Function2] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new e0(this.f3358d, this.f3359e, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((e0) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:28:0x003b, code lost:
+    
+        if (r7.lock(null, r6) == r0) goto L19;
+     */
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r1v2, types: [kotlin.jvm.functions.Function2] */
+    /* JADX WARN: Type inference failed for: r1v5 */
+    /* JADX WARN: Type inference failed for: r1v6 */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final java.lang.Object invokeSuspend(java.lang.Object r7) {
+        /*
+            r6 = this;
+            java.lang.Object r0 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r1 = r6.f3357c
+            r2 = 2
+            r3 = 1
+            r4 = 0
+            if (r1 == 0) goto L2a
+            if (r1 == r3) goto L1f
+            if (r1 != r2) goto L17
+            kotlinx.coroutines.sync.Mutex r6 = r6.f3355a
+            kotlin.ResultKt.throwOnFailure(r7)     // Catch: java.lang.Throwable -> L15
+            goto L51
+        L15:
+            r7 = move-exception
+            goto L5d
+        L17:
+            java.lang.IllegalStateException r6 = new java.lang.IllegalStateException
+            java.lang.String r7 = "call to 'resume' before 'invoke' with coroutine"
+            r6.<init>(r7)
+            throw r6
+        L1f:
+            kotlin.coroutines.jvm.internal.SuspendLambda r1 = r6.f3356b
+            kotlin.jvm.functions.Function2 r1 = (kotlin.jvm.functions.Function2) r1
+            kotlinx.coroutines.sync.Mutex r3 = r6.f3355a
+            kotlin.ResultKt.throwOnFailure(r7)
+            r7 = r3
+            goto L3e
+        L2a:
+            kotlin.ResultKt.throwOnFailure(r7)
+            kotlinx.coroutines.sync.Mutex r7 = r6.f3358d
+            r6.f3355a = r7
+            kotlin.coroutines.jvm.internal.SuspendLambda r1 = r6.f3359e
+            r6.f3356b = r1
+            r6.f3357c = r3
+            java.lang.Object r3 = r7.lock(r4, r6)
+            if (r3 != r0) goto L3e
+            goto L4f
+        L3e:
+            androidx.lifecycle.d0 r3 = new androidx.lifecycle.d0     // Catch: java.lang.Throwable -> L59
+            r3.<init>(r1, r4)     // Catch: java.lang.Throwable -> L59
+            r6.f3355a = r7     // Catch: java.lang.Throwable -> L59
+            r6.f3356b = r4     // Catch: java.lang.Throwable -> L59
+            r6.f3357c = r2     // Catch: java.lang.Throwable -> L59
+            java.lang.Object r6 = kotlinx.coroutines.CoroutineScopeKt.coroutineScope(r3, r6)     // Catch: java.lang.Throwable -> L59
+            if (r6 != r0) goto L50
+        L4f:
+            return r0
+        L50:
+            r6 = r7
+        L51:
+            kotlin.Unit r7 = kotlin.Unit.INSTANCE     // Catch: java.lang.Throwable -> L15
+            r6.unlock(r4)
+            kotlin.Unit r6 = kotlin.Unit.INSTANCE
+            return r6
+        L59:
+            r6 = move-exception
+            r5 = r7
+            r7 = r6
+            r6 = r5
+        L5d:
+            r6.unlock(r4)
+            throw r7
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.lifecycle.e0.invokeSuspend(java.lang.Object):java.lang.Object");
+    }
+}

apk_decompiled/sources/androidx/lifecycle/f0.java

@@ -0,0 +1,76 @@
+package androidx.lifecycle;
+
+import java.util.concurrent.CancellationException;
+import kotlin.Result;
+import kotlin.Unit;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Ref;
+import kotlinx.coroutines.BuildersKt__Builders_commonKt;
+import kotlinx.coroutines.CancellableContinuationImpl;
+import kotlinx.coroutines.CoroutineScope;
+import kotlinx.coroutines.Job;
+import kotlinx.coroutines.sync.Mutex;
+
+/* loaded from: classes.dex */
+public final class f0 implements H {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ A f3362a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ Ref.ObjectRef f3363b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ CoroutineScope f3364c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ A f3365d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ CancellableContinuationImpl f3366e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final /* synthetic */ Mutex f3367f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public final /* synthetic */ SuspendLambda f3368g;
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public f0(A a2, Ref.ObjectRef objectRef, CoroutineScope coroutineScope, A a4, CancellableContinuationImpl cancellableContinuationImpl, Mutex mutex, Function2 function2) {
+        this.f3362a = a2;
+        this.f3363b = objectRef;
+        this.f3364c = coroutineScope;
+        this.f3365d = a4;
+        this.f3366e = cancellableContinuationImpl;
+        this.f3367f = mutex;
+        this.f3368g = (SuspendLambda) function2;
+    }
+
+    /* JADX WARN: Type inference failed for: r10v1, types: [kotlin.coroutines.jvm.internal.SuspendLambda, kotlin.jvm.functions.Function2] */
+    /* JADX WARN: Type inference failed for: r8v2, types: [T, kotlinx.coroutines.Job] */
+    @Override // androidx.lifecycle.H
+    public final void onStateChanged(J j4, A event) {
+        ?? launch$default;
+        Intrinsics.checkNotNullParameter(j4, "<anonymous parameter 0>");
+        Intrinsics.checkNotNullParameter(event, "event");
+        Ref.ObjectRef objectRef = this.f3363b;
+        if (event == this.f3362a) {
+            launch$default = BuildersKt__Builders_commonKt.launch$default(this.f3364c, null, null, new e0(this.f3367f, this.f3368g, null), 3, null);
+            objectRef.element = launch$default;
+            return;
+        }
+        if (event == this.f3365d) {
+            Job job = (Job) objectRef.element;
+            if (job != null) {
+                Job.DefaultImpls.cancel$default(job, (CancellationException) null, 1, (Object) null);
+            }
+            objectRef.element = null;
+        }
+        if (event == A.ON_DESTROY) {
+            Result.Companion companion = Result.INSTANCE;
+            this.f3366e.resumeWith(Result.m116constructorimpl(Unit.INSTANCE));
+        }
+    }
+}

apk_decompiled/sources/androidx/lifecycle/g0.java

@@ -0,0 +1,172 @@
+package androidx.lifecycle;
+
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Ref;
+import kotlinx.coroutines.CoroutineScope;
+
+/* loaded from: classes.dex */
+public final class g0 extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public Ref.ObjectRef f3372a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public Ref.ObjectRef f3373b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public CoroutineScope f3374c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public int f3375d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ C f3376e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final /* synthetic */ CoroutineScope f3377f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public final /* synthetic */ SuspendLambda f3378g;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    /* JADX WARN: Multi-variable type inference failed */
+    public g0(C c4, CoroutineScope coroutineScope, Function2 function2, Continuation continuation) {
+        super(2, continuation);
+        this.f3376e = c4;
+        this.f3377f = coroutineScope;
+        this.f3378g = (SuspendLambda) function2;
+    }
+
+    /* JADX WARN: Type inference failed for: r0v0, types: [kotlin.coroutines.jvm.internal.SuspendLambda, kotlin.jvm.functions.Function2] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new g0(this.f3376e, this.f3377f, this.f3378g, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((g0) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Removed duplicated region for block: B:21:0x00ab  */
+    /* JADX WARN: Removed duplicated region for block: B:24:0x00b4  */
+    /* JADX WARN: Removed duplicated region for block: B:26:? A[SYNTHETIC] */
+    /* JADX WARN: Type inference failed for: r12v0, types: [kotlin.coroutines.jvm.internal.SuspendLambda, kotlin.jvm.functions.Function2] */
+    /* JADX WARN: Type inference failed for: r5v2, types: [T, java.lang.Object, androidx.lifecycle.f0, androidx.lifecycle.I] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final java.lang.Object invokeSuspend(java.lang.Object r14) {
+        /*
+            r13 = this;
+            java.lang.Object r0 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r1 = r13.f3375d
+            androidx.lifecycle.C r2 = r13.f3376e
+            r3 = 0
+            r4 = 1
+            if (r1 == 0) goto L23
+            if (r1 != r4) goto L1b
+            kotlin.jvm.internal.Ref$ObjectRef r1 = r13.f3373b
+            kotlin.jvm.internal.Ref$ObjectRef r13 = r13.f3372a
+            kotlin.ResultKt.throwOnFailure(r14)     // Catch: java.lang.Throwable -> L17
+            goto L8c
+        L17:
+            r0 = move-exception
+            r14 = r0
+            goto La5
+        L1b:
+            java.lang.IllegalStateException r13 = new java.lang.IllegalStateException
+            java.lang.String r14 = "call to 'resume' before 'invoke' with coroutine"
+            r13.<init>(r14)
+            throw r13
+        L23:
+            kotlin.ResultKt.throwOnFailure(r14)
+            androidx.lifecycle.B r14 = r2.b()
+            androidx.lifecycle.B r1 = androidx.lifecycle.B.f3280a
+            if (r14 != r1) goto L31
+            kotlin.Unit r13 = kotlin.Unit.INSTANCE
+            return r13
+        L31:
+            kotlin.jvm.internal.Ref$ObjectRef r7 = new kotlin.jvm.internal.Ref$ObjectRef
+            r7.<init>()
+            kotlin.jvm.internal.Ref$ObjectRef r1 = new kotlin.jvm.internal.Ref$ObjectRef
+            r1.<init>()
+            androidx.lifecycle.B r14 = androidx.lifecycle.B.f3283d     // Catch: java.lang.Throwable -> L84
+            kotlinx.coroutines.CoroutineScope r8 = r13.f3377f     // Catch: java.lang.Throwable -> L84
+            kotlin.coroutines.jvm.internal.SuspendLambda r12 = r13.f3378g     // Catch: java.lang.Throwable -> L84
+            r13.f3372a = r7     // Catch: java.lang.Throwable -> L84
+            r13.f3373b = r1     // Catch: java.lang.Throwable -> L84
+            r13.f3374c = r8     // Catch: java.lang.Throwable -> L84
+            r13.f3375d = r4     // Catch: java.lang.Throwable -> L84
+            kotlinx.coroutines.CancellableContinuationImpl r10 = new kotlinx.coroutines.CancellableContinuationImpl     // Catch: java.lang.Throwable -> L84
+            kotlin.coroutines.Continuation r5 = kotlin.coroutines.intrinsics.IntrinsicsKt.intercepted(r13)     // Catch: java.lang.Throwable -> L84
+            r10.<init>(r5, r4)     // Catch: java.lang.Throwable -> L84
+            r10.initCancellability()     // Catch: java.lang.Throwable -> L84
+            androidx.lifecycle.y r5 = androidx.lifecycle.A.Companion     // Catch: java.lang.Throwable -> L84
+            r5.getClass()     // Catch: java.lang.Throwable -> La1
+            androidx.lifecycle.A r6 = androidx.lifecycle.C0203y.c(r14)     // Catch: java.lang.Throwable -> La1
+            androidx.lifecycle.A r9 = androidx.lifecycle.C0203y.a(r14)     // Catch: java.lang.Throwable -> L84
+            r14 = 0
+            kotlinx.coroutines.sync.Mutex r11 = kotlinx.coroutines.sync.MutexKt.Mutex$default(r14, r4, r3)     // Catch: java.lang.Throwable -> L84
+            androidx.lifecycle.f0 r5 = new androidx.lifecycle.f0     // Catch: java.lang.Throwable -> L84
+            r5.<init>(r6, r7, r8, r9, r10, r11, r12)     // Catch: java.lang.Throwable -> L84
+            r1.element = r5     // Catch: java.lang.Throwable -> L84
+            java.lang.String r14 = "null cannot be cast to non-null type androidx.lifecycle.LifecycleEventObserver"
+            kotlin.jvm.internal.Intrinsics.checkNotNull(r5, r14)     // Catch: java.lang.Throwable -> L84
+            r2.a(r5)     // Catch: java.lang.Throwable -> L84
+            java.lang.Object r14 = r10.getResult()     // Catch: java.lang.Throwable -> L84
+            java.lang.Object r5 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()     // Catch: java.lang.Throwable -> L84
+            if (r14 != r5) goto L88
+            kotlin.coroutines.jvm.internal.DebugProbesKt.probeCoroutineSuspended(r13)     // Catch: java.lang.Throwable -> L84
+            goto L88
+        L84:
+            r0 = move-exception
+            r14 = r0
+        L86:
+            r13 = r7
+            goto La5
+        L88:
+            if (r14 != r0) goto L8b
+            return r0
+        L8b:
+            r13 = r7
+        L8c:
+            T r13 = r13.element
+            kotlinx.coroutines.Job r13 = (kotlinx.coroutines.Job) r13
+            if (r13 == 0) goto L95
+            kotlinx.coroutines.Job.DefaultImpls.cancel$default(r13, r3, r4, r3)
+        L95:
+            T r13 = r1.element
+            androidx.lifecycle.H r13 = (androidx.lifecycle.H) r13
+            if (r13 == 0) goto L9e
+            r2.c(r13)
+        L9e:
+            kotlin.Unit r13 = kotlin.Unit.INSTANCE
+            return r13
+        La1:
+            r0 = move-exception
+            r13 = r0
+            r14 = r13
+            goto L86
+        La5:
+            T r13 = r13.element
+            kotlinx.coroutines.Job r13 = (kotlinx.coroutines.Job) r13
+            if (r13 == 0) goto Lae
+            kotlinx.coroutines.Job.DefaultImpls.cancel$default(r13, r3, r4, r3)
+        Lae:
+            T r13 = r1.element
+            androidx.lifecycle.H r13 = (androidx.lifecycle.H) r13
+            if (r13 == 0) goto Lb7
+            r2.c(r13)
+        Lb7:
+            throw r14
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.lifecycle.g0.invokeSuspend(java.lang.Object):java.lang.Object");
+    }
+}

apk_decompiled/sources/androidx/lifecycle/h0.java

@@ -0,0 +1,72 @@
+package androidx.lifecycle;
+
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.BuildersKt;
+import kotlinx.coroutines.CoroutineScope;
+import kotlinx.coroutines.Dispatchers;
+import kotlinx.coroutines.MainCoroutineDispatcher;
+
+/* loaded from: classes.dex */
+public final class h0 extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f3383a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public /* synthetic */ Object f3384b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ C f3385c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ SuspendLambda f3386d;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    /* JADX WARN: Multi-variable type inference failed */
+    public h0(C c4, Function2 function2, Continuation continuation) {
+        super(2, continuation);
+        this.f3385c = c4;
+        this.f3386d = (SuspendLambda) function2;
+    }
+
+    /* JADX WARN: Type inference failed for: r1v0, types: [kotlin.coroutines.jvm.internal.SuspendLambda, kotlin.jvm.functions.Function2] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        h0 h0Var = new h0(this.f3385c, this.f3386d, continuation);
+        h0Var.f3384b = obj;
+        return h0Var;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((h0) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    /* JADX WARN: Type inference failed for: r4v0, types: [kotlin.coroutines.jvm.internal.SuspendLambda, kotlin.jvm.functions.Function2] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f3383a;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            CoroutineScope coroutineScope = (CoroutineScope) this.f3384b;
+            MainCoroutineDispatcher immediate = Dispatchers.getMain().getImmediate();
+            g0 g0Var = new g0(this.f3385c, coroutineScope, this.f3386d, null);
+            this.f3383a = 1;
+            if (BuildersKt.withContext(immediate, g0Var, this) == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        return Unit.INSTANCE;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/i0.java

@@ -0,0 +1,34 @@
+package androidx.lifecycle;
+
+import android.app.Activity;
+import android.app.Fragment;
+import android.app.FragmentManager;
+import androidx.lifecycle.k0;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public abstract class i0 {
+    /* JADX WARN: Multi-variable type inference failed */
+    public static void a(Activity activity, A event) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+        Intrinsics.checkNotNullParameter(event, "event");
+        if (activity instanceof J) {
+            C lifecycle = ((J) activity).getLifecycle();
+            if (lifecycle instanceof L) {
+                ((L) lifecycle).f(event);
+            }
+        }
+    }
+
+    public static void b(Activity activity) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+        k0.a.Companion.getClass();
+        Intrinsics.checkNotNullParameter(activity, "activity");
+        activity.registerActivityLifecycleCallbacks(new k0.a());
+        FragmentManager fragmentManager = activity.getFragmentManager();
+        if (fragmentManager.findFragmentByTag("androidx.lifecycle.LifecycleDispatcher.report_fragment_tag") == null) {
+            fragmentManager.beginTransaction().add(new Fragment(), "androidx.lifecycle.LifecycleDispatcher.report_fragment_tag").commit();
+            fragmentManager.executePendingTransactions();
+        }
+    }
+}

apk_decompiled/sources/androidx/lifecycle/j0.java

@@ -0,0 +1,5 @@
+package androidx.lifecycle;
+
+/* loaded from: classes.dex */
+public final class j0 {
+}

apk_decompiled/sources/androidx/lifecycle/k0.java

@@ -0,0 +1,105 @@
+package androidx.lifecycle;
+
+import android.app.Activity;
+import android.app.Application;
+import android.app.Fragment;
+import android.os.Bundle;
+import kotlin.jvm.JvmStatic;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public class k0 extends Fragment {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final /* synthetic */ int f3396a = 0;
+
+    /* loaded from: classes.dex */
+    public static final class a implements Application.ActivityLifecycleCallbacks {
+        public static final j0 Companion = new Object();
+
+        @JvmStatic
+        public static final void registerIn(Activity activity) {
+            Companion.getClass();
+            Intrinsics.checkNotNullParameter(activity, "activity");
+            activity.registerActivityLifecycleCallbacks(new a());
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityCreated(Activity activity, Bundle bundle) {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityDestroyed(Activity activity) {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityPaused(Activity activity) {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityPostCreated(Activity activity, Bundle bundle) {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+            int i = k0.f3396a;
+            i0.a(activity, A.ON_CREATE);
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityPostResumed(Activity activity) {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+            int i = k0.f3396a;
+            i0.a(activity, A.ON_RESUME);
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityPostStarted(Activity activity) {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+            int i = k0.f3396a;
+            i0.a(activity, A.ON_START);
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityPreDestroyed(Activity activity) {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+            int i = k0.f3396a;
+            i0.a(activity, A.ON_DESTROY);
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityPrePaused(Activity activity) {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+            int i = k0.f3396a;
+            i0.a(activity, A.ON_PAUSE);
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityPreStopped(Activity activity) {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+            int i = k0.f3396a;
+            i0.a(activity, A.ON_STOP);
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityResumed(Activity activity) {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivitySaveInstanceState(Activity activity, Bundle bundle) {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+            Intrinsics.checkNotNullParameter(bundle, "bundle");
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityStarted(Activity activity) {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityStopped(Activity activity) {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+        }
+    }
+}

apk_decompiled/sources/androidx/lifecycle/l0.java

@@ -0,0 +1,31 @@
+package androidx.lifecycle;
+
+import android.os.Bundle;
+import v0.InterfaceC0638c;
+
+/* loaded from: classes.dex */
+public final /* synthetic */ class l0 implements InterfaceC0638c {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f3399a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ Object f3400b;
+
+    public /* synthetic */ l0(Object obj, int i) {
+        this.f3399a = i;
+        this.f3400b = obj;
+    }
+
+    @Override // v0.InterfaceC0638c
+    public final Bundle a() {
+        int i = this.f3399a;
+        Object obj = this.f3400b;
+        switch (i) {
+            case 0:
+                return n0.a((n0) obj);
+            default:
+                return b.o.c((b.o) obj);
+        }
+    }
+}

apk_decompiled/sources/androidx/lifecycle/m0.java

@@ -0,0 +1,29 @@
+package androidx.lifecycle;
+
+import java.util.LinkedHashMap;
+import kotlinx.coroutines.flow.MutableStateFlow;
+
+/* loaded from: classes.dex */
+public final class m0 extends X {
+
+    /* renamed from: l, reason: collision with root package name */
+    public String f3401l;
+
+    /* renamed from: m, reason: collision with root package name */
+    public n0 f3402m;
+
+    @Override // androidx.lifecycle.X, androidx.lifecycle.Q
+    public final void j(Object obj) {
+        n0 n0Var = this.f3402m;
+        if (n0Var != null) {
+            LinkedHashMap linkedHashMap = n0Var.f3404a;
+            String str = this.f3401l;
+            linkedHashMap.put(str, obj);
+            MutableStateFlow mutableStateFlow = (MutableStateFlow) n0Var.f3407d.get(str);
+            if (mutableStateFlow != null) {
+                mutableStateFlow.setValue(obj);
+            }
+        }
+        super.j(obj);
+    }
+}

apk_decompiled/sources/androidx/lifecycle/n0.java

@@ -0,0 +1,130 @@
+package androidx.lifecycle;
+
+import a.AbstractC0106b;
+import android.os.Binder;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.util.Size;
+import android.util.SizeF;
+import android.util.SparseArray;
+import com.google.firebase.crashlytics.internal.metadata.UserMetadata;
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import kotlin.TuplesKt;
+import kotlin.collections.MapsKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.flow.MutableStateFlow;
+import v0.InterfaceC0638c;
+
+/* loaded from: classes.dex */
+public final class n0 {
+
+    /* renamed from: f, reason: collision with root package name */
+    public static final Class[] f3403f = {Boolean.TYPE, boolean[].class, Double.TYPE, double[].class, Integer.TYPE, int[].class, Long.TYPE, long[].class, String.class, String[].class, Binder.class, Bundle.class, Byte.TYPE, byte[].class, Character.TYPE, char[].class, CharSequence.class, CharSequence[].class, ArrayList.class, Float.TYPE, float[].class, Parcelable.class, Parcelable[].class, Serializable.class, Short.TYPE, short[].class, SparseArray.class, Size.class, SizeF.class};
+
+    /* renamed from: a, reason: collision with root package name */
+    public final LinkedHashMap f3404a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final LinkedHashMap f3405b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final LinkedHashMap f3406c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final LinkedHashMap f3407d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final InterfaceC0638c f3408e;
+
+    public n0(HashMap initialState) {
+        Intrinsics.checkNotNullParameter(initialState, "initialState");
+        LinkedHashMap linkedHashMap = new LinkedHashMap();
+        this.f3404a = linkedHashMap;
+        this.f3405b = new LinkedHashMap();
+        this.f3406c = new LinkedHashMap();
+        this.f3407d = new LinkedHashMap();
+        this.f3408e = new l0(this, 0);
+        linkedHashMap.putAll(initialState);
+    }
+
+    public static Bundle a(n0 this$0) {
+        Intrinsics.checkNotNullParameter(this$0, "this$0");
+        for (Map.Entry entry : MapsKt.toMap(this$0.f3405b).entrySet()) {
+            this$0.d(((InterfaceC0638c) entry.getValue()).a(), (String) entry.getKey());
+        }
+        LinkedHashMap linkedHashMap = this$0.f3404a;
+        Set<String> keySet = linkedHashMap.keySet();
+        ArrayList arrayList = new ArrayList(keySet.size());
+        ArrayList arrayList2 = new ArrayList(arrayList.size());
+        for (String str : keySet) {
+            arrayList.add(str);
+            arrayList2.add(linkedHashMap.get(str));
+        }
+        return AbstractC0106b.b(TuplesKt.to(UserMetadata.KEYDATA_FILENAME, arrayList), TuplesKt.to("values", arrayList2));
+    }
+
+    public final boolean b(String key) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        return this.f3404a.containsKey(key);
+    }
+
+    public final Object c(String key) {
+        LinkedHashMap linkedHashMap = this.f3404a;
+        Intrinsics.checkNotNullParameter(key, "key");
+        try {
+            return linkedHashMap.get(key);
+        } catch (ClassCastException unused) {
+            Intrinsics.checkNotNullParameter(key, "key");
+            linkedHashMap.remove(key);
+            m0 m0Var = (m0) this.f3406c.remove(key);
+            if (m0Var != null) {
+                m0Var.f3402m = null;
+            }
+            this.f3407d.remove(key);
+            return null;
+        }
+    }
+
+    public final void d(Object obj, String key) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        if (obj != null) {
+            Class[] clsArr = f3403f;
+            for (int i = 0; i < 29; i++) {
+                Class cls = clsArr[i];
+                Intrinsics.checkNotNull(cls);
+                if (!cls.isInstance(obj)) {
+                }
+            }
+            StringBuilder sb = new StringBuilder("Can't put value with type ");
+            Intrinsics.checkNotNull(obj);
+            sb.append(obj.getClass());
+            sb.append(" into saved state");
+            throw new IllegalArgumentException(sb.toString());
+        }
+        Object obj2 = this.f3406c.get(key);
+        X x3 = obj2 instanceof X ? (X) obj2 : null;
+        if (x3 != null) {
+            x3.j(obj);
+        } else {
+            this.f3404a.put(key, obj);
+        }
+        MutableStateFlow mutableStateFlow = (MutableStateFlow) this.f3407d.get(key);
+        if (mutableStateFlow == null) {
+            return;
+        }
+        mutableStateFlow.setValue(obj);
+    }
+
+    public n0() {
+        this.f3404a = new LinkedHashMap();
+        this.f3405b = new LinkedHashMap();
+        this.f3406c = new LinkedHashMap();
+        this.f3407d = new LinkedHashMap();
+        this.f3408e = new l0(this, 0);
+    }
+}

apk_decompiled/sources/androidx/lifecycle/o0.java

@@ -0,0 +1,50 @@
+package androidx.lifecycle;
+
+import java.io.Closeable;
+import kotlin.jvm.internal.Intrinsics;
+import v0.C0639d;
+
+/* loaded from: classes.dex */
+public final class o0 implements H, Closeable {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final String f3412a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final n0 f3413b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public boolean f3414c;
+
+    public o0(String key, n0 handle) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        Intrinsics.checkNotNullParameter(handle, "handle");
+        this.f3412a = key;
+        this.f3413b = handle;
+    }
+
+    public final void Y(C0639d registry, C lifecycle) {
+        Intrinsics.checkNotNullParameter(registry, "registry");
+        Intrinsics.checkNotNullParameter(lifecycle, "lifecycle");
+        if (this.f3414c) {
+            throw new IllegalStateException("Already attached to lifecycleOwner");
+        }
+        this.f3414c = true;
+        lifecycle.a(this);
+        registry.c(this.f3412a, this.f3413b.f3408e);
+    }
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    public final void close() {
+    }
+
+    @Override // androidx.lifecycle.H
+    public final void onStateChanged(J source, A event) {
+        Intrinsics.checkNotNullParameter(source, "source");
+        Intrinsics.checkNotNullParameter(event, "event");
+        if (event == A.ON_DESTROY) {
+            this.f3414c = false;
+            source.getLifecycle().c(this);
+        }
+    }
+}

apk_decompiled/sources/androidx/lifecycle/p0.java

@@ -0,0 +1,13 @@
+package androidx.lifecycle;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class p0 implements y0 {
+    @Override // androidx.lifecycle.y0
+    public final w0 create(Class modelClass, l0.c extras) {
+        Intrinsics.checkNotNullParameter(modelClass, "modelClass");
+        Intrinsics.checkNotNullParameter(extras, "extras");
+        return new s0();
+    }
+}

apk_decompiled/sources/androidx/lifecycle/q0.java

@@ -0,0 +1,273 @@
+package androidx.lifecycle;
+
+import android.os.Bundle;
+import android.view.View;
+import com.adif.elcanomovil.R;
+import com.google.firebase.crashlytics.internal.metadata.UserMetadata;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.concurrent.atomic.AtomicReference;
+import kotlin.NotImplementedError;
+import kotlin.Unit;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.coroutines.EmptyCoroutineContext;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.JvmClassMappingKt;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.BuildersKt;
+import kotlinx.coroutines.CoroutineScopeKt;
+import kotlinx.coroutines.Dispatchers;
+import kotlinx.coroutines.Job;
+import kotlinx.coroutines.SupervisorKt;
+import kotlinx.coroutines.flow.Flow;
+import kotlinx.coroutines.flow.StateFlow;
+import l0.C0435a;
+import m0.C0501a;
+import m0.C0503c;
+import n.C0508b;
+import v0.C0636a;
+import v0.C0639d;
+import v0.InterfaceC0638c;
+
+/* loaded from: classes.dex */
+public abstract class q0 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final E2.e f3417a = new E2.e(23);
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final E2.e f3418b = new E2.e(24);
+
+    /* renamed from: c, reason: collision with root package name */
+    public static final E2.e f3419c = new E2.e(22);
+
+    /* renamed from: d, reason: collision with root package name */
+    public static final C0503c f3420d = new Object();
+
+    public static C0189j a(Flow flow, CoroutineContext context, int i) {
+        if ((i & 1) != 0) {
+            context = EmptyCoroutineContext.INSTANCE;
+        }
+        Intrinsics.checkNotNullParameter(flow, "<this>");
+        Intrinsics.checkNotNullParameter(context, "context");
+        C0189j k4 = k(context, new C0198t(flow, null));
+        if (flow instanceof StateFlow) {
+            if (C0508b.L().M()) {
+                k4.j(((StateFlow) flow).getValue());
+                return k4;
+            }
+            k4.k(((StateFlow) flow).getValue());
+        }
+        return k4;
+    }
+
+    public static final void b(w0 viewModel, C0639d registry, C lifecycle) {
+        Intrinsics.checkNotNullParameter(viewModel, "viewModel");
+        Intrinsics.checkNotNullParameter(registry, "registry");
+        Intrinsics.checkNotNullParameter(lifecycle, "lifecycle");
+        o0 o0Var = (o0) viewModel.getCloseable("androidx.lifecycle.savedstate.vm.tag");
+        if (o0Var == null || o0Var.f3414c) {
+            return;
+        }
+        o0Var.Y(registry, lifecycle);
+        n(registry, lifecycle);
+    }
+
+    public static final o0 c(C0639d registry, C lifecycle, String str, Bundle bundle) {
+        Intrinsics.checkNotNullParameter(registry, "registry");
+        Intrinsics.checkNotNullParameter(lifecycle, "lifecycle");
+        Intrinsics.checkNotNull(str);
+        Bundle a2 = registry.a(str);
+        Class[] clsArr = n0.f3403f;
+        o0 o0Var = new o0(str, d(a2, bundle));
+        o0Var.Y(registry, lifecycle);
+        n(registry, lifecycle);
+        return o0Var;
+    }
+
+    public static n0 d(Bundle bundle, Bundle bundle2) {
+        if (bundle == null) {
+            if (bundle2 == null) {
+                return new n0();
+            }
+            HashMap hashMap = new HashMap();
+            for (String key : bundle2.keySet()) {
+                Intrinsics.checkNotNullExpressionValue(key, "key");
+                hashMap.put(key, bundle2.get(key));
+            }
+            return new n0(hashMap);
+        }
+        ClassLoader classLoader = n0.class.getClassLoader();
+        Intrinsics.checkNotNull(classLoader);
+        bundle.setClassLoader(classLoader);
+        ArrayList parcelableArrayList = bundle.getParcelableArrayList(UserMetadata.KEYDATA_FILENAME);
+        ArrayList parcelableArrayList2 = bundle.getParcelableArrayList("values");
+        if (parcelableArrayList == null || parcelableArrayList2 == null || parcelableArrayList.size() != parcelableArrayList2.size()) {
+            throw new IllegalStateException("Invalid bundle passed as restored state");
+        }
+        LinkedHashMap linkedHashMap = new LinkedHashMap();
+        int size = parcelableArrayList.size();
+        for (int i = 0; i < size; i++) {
+            Object obj = parcelableArrayList.get(i);
+            Intrinsics.checkNotNull(obj, "null cannot be cast to non-null type kotlin.String");
+            linkedHashMap.put((String) obj, parcelableArrayList2.get(i));
+        }
+        return new n0(linkedHashMap);
+    }
+
+    public static final n0 e(l0.c cVar) {
+        Intrinsics.checkNotNullParameter(cVar, "<this>");
+        v0.f fVar = (v0.f) cVar.a(f3417a);
+        if (fVar == null) {
+            throw new IllegalArgumentException("CreationExtras must have a value by `SAVED_STATE_REGISTRY_OWNER_KEY`");
+        }
+        D0 d02 = (D0) cVar.a(f3418b);
+        if (d02 == null) {
+            throw new IllegalArgumentException("CreationExtras must have a value by `VIEW_MODEL_STORE_OWNER_KEY`");
+        }
+        Bundle bundle = (Bundle) cVar.a(f3419c);
+        String key = (String) cVar.a(C0503c.f7792a);
+        if (key == null) {
+            throw new IllegalArgumentException("CreationExtras must have a value by `VIEW_MODEL_KEY`");
+        }
+        Intrinsics.checkNotNullParameter(fVar, "<this>");
+        InterfaceC0638c b4 = fVar.getSavedStateRegistry().b();
+        r0 r0Var = b4 instanceof r0 ? (r0) b4 : null;
+        if (r0Var == null) {
+            throw new IllegalStateException("enableSavedStateHandles() wasn't called prior to createSavedStateHandle() call");
+        }
+        s0 i = i(d02);
+        n0 n0Var = (n0) i.f3428a.get(key);
+        if (n0Var != null) {
+            return n0Var;
+        }
+        Class[] clsArr = n0.f3403f;
+        Intrinsics.checkNotNullParameter(key, "key");
+        r0Var.c();
+        Bundle bundle2 = r0Var.f3426c;
+        Bundle bundle3 = bundle2 != null ? bundle2.getBundle(key) : null;
+        Bundle bundle4 = r0Var.f3426c;
+        if (bundle4 != null) {
+            bundle4.remove(key);
+        }
+        Bundle bundle5 = r0Var.f3426c;
+        if (bundle5 != null && bundle5.isEmpty()) {
+            r0Var.f3426c = null;
+        }
+        n0 d4 = d(bundle3, bundle);
+        i.f3428a.put(key, d4);
+        return d4;
+    }
+
+    public static final void f(v0.f fVar) {
+        Intrinsics.checkNotNullParameter(fVar, "<this>");
+        B b4 = fVar.getLifecycle().b();
+        if (b4 != B.f3281b && b4 != B.f3282c) {
+            throw new IllegalArgumentException("Failed requirement.");
+        }
+        if (fVar.getSavedStateRegistry().b() == null) {
+            r0 r0Var = new r0(fVar.getSavedStateRegistry(), (D0) fVar);
+            fVar.getSavedStateRegistry().c("androidx.lifecycle.internal.SavedStateHandlesProvider", r0Var);
+            fVar.getLifecycle().a(new C0636a(r0Var));
+        }
+    }
+
+    public static final E g(C c4) {
+        Intrinsics.checkNotNullParameter(c4, "<this>");
+        while (true) {
+            E e4 = (E) c4.f3287a.get();
+            if (e4 != null) {
+                return e4;
+            }
+            E e5 = new E(c4, SupervisorKt.SupervisorJob$default((Job) null, 1, (Object) null).plus(Dispatchers.getMain().getImmediate()));
+            AtomicReference atomicReference = c4.f3287a;
+            while (!atomicReference.compareAndSet(null, e5)) {
+                if (atomicReference.get() != null) {
+                    break;
+                }
+            }
+            BuildersKt.launch$default(e5, Dispatchers.getMain().getImmediate(), null, new D(e5, null), 2, null);
+            return e5;
+        }
+    }
+
+    public static final E h(J j4) {
+        Intrinsics.checkNotNullParameter(j4, "<this>");
+        return g(j4.getLifecycle());
+    }
+
+    /* JADX WARN: Type inference failed for: r0v1, types: [java.lang.Object, androidx.lifecycle.y0] */
+    public static final s0 i(D0 owner) {
+        Intrinsics.checkNotNullParameter(owner, "<this>");
+        ?? factory = new Object();
+        Intrinsics.checkNotNullParameter(owner, "owner");
+        Intrinsics.checkNotNullParameter(factory, "factory");
+        C0 store = owner.getViewModelStore();
+        Intrinsics.checkNotNullParameter(owner, "owner");
+        l0.c defaultCreationExtras = owner instanceof InterfaceC0200v ? ((InterfaceC0200v) owner).getDefaultViewModelCreationExtras() : C0435a.f7312b;
+        Intrinsics.checkNotNullParameter(store, "store");
+        Intrinsics.checkNotNullParameter(factory, "factory");
+        Intrinsics.checkNotNullParameter(defaultCreationExtras, "defaultCreationExtras");
+        R0.h hVar = new R0.h(store, (y0) factory, defaultCreationExtras);
+        Intrinsics.checkNotNullParameter("androidx.lifecycle.internal.SavedStateHandlesVM", "key");
+        Intrinsics.checkNotNullParameter(s0.class, "modelClass");
+        return (s0) hVar.i(JvmClassMappingKt.getKotlinClass(s0.class), "androidx.lifecycle.internal.SavedStateHandlesVM");
+    }
+
+    public static final C0501a j(w0 w0Var) {
+        C0501a c0501a;
+        CoroutineContext coroutineContext;
+        Intrinsics.checkNotNullParameter(w0Var, "<this>");
+        synchronized (f3420d) {
+            c0501a = (C0501a) w0Var.getCloseable("androidx.lifecycle.viewmodel.internal.ViewModelCoroutineScope.JOB_KEY");
+            if (c0501a == null) {
+                try {
+                    try {
+                        coroutineContext = Dispatchers.getMain().getImmediate();
+                    } catch (NotImplementedError unused) {
+                        coroutineContext = EmptyCoroutineContext.INSTANCE;
+                    }
+                } catch (IllegalStateException unused2) {
+                    coroutineContext = EmptyCoroutineContext.INSTANCE;
+                }
+                C0501a c0501a2 = new C0501a(coroutineContext.plus(SupervisorKt.SupervisorJob$default((Job) null, 1, (Object) null)));
+                w0Var.addCloseable("androidx.lifecycle.viewmodel.internal.ViewModelCoroutineScope.JOB_KEY", c0501a2);
+                c0501a = c0501a2;
+            }
+        }
+        return c0501a;
+    }
+
+    /* JADX WARN: Type inference failed for: r2v0, types: [androidx.lifecycle.W, java.lang.Object, androidx.lifecycle.j] */
+    public static final C0189j k(CoroutineContext context, Function2 block) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(block, "block");
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(block, "block");
+        ?? w3 = new W();
+        w3.f3392m = new C0182d(w3, block, CoroutineScopeKt.CoroutineScope(Dispatchers.getMain().getImmediate().plus(context).plus(SupervisorKt.SupervisorJob((Job) context.get(Job.INSTANCE)))), new J0.e(w3, 2));
+        return w3;
+    }
+
+    public static final Object l(C c4, Function2 function2, SuspendLambda suspendLambda) {
+        Object coroutineScope;
+        return (c4.b() != B.f3280a && (coroutineScope = CoroutineScopeKt.coroutineScope(new h0(c4, function2, null), suspendLambda)) == IntrinsicsKt.getCOROUTINE_SUSPENDED()) ? coroutineScope : Unit.INSTANCE;
+    }
+
+    public static final void m(View view, J j4) {
+        Intrinsics.checkNotNullParameter(view, "<this>");
+        view.setTag(R.id.view_tree_lifecycle_owner, j4);
+    }
+
+    public static void n(C0639d c0639d, C c4) {
+        B b4 = c4.b();
+        if (b4 == B.f3281b || b4.a(B.f3283d)) {
+            c0639d.d();
+        } else {
+            c4.a(new C0194o(1, c4, c0639d));
+        }
+    }
+}

apk_decompiled/sources/androidx/lifecycle/r.java

@@ -0,0 +1,32 @@
+package androidx.lifecycle;
+
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.BuildersKt__Builders_commonKt;
+import kotlinx.coroutines.CoroutineScopeKt;
+import kotlinx.coroutines.Dispatchers;
+import kotlinx.coroutines.DisposableHandle;
+
+/* loaded from: classes.dex */
+public final class r implements DisposableHandle {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Q f3421a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final C0189j f3422b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public boolean f3423c;
+
+    public r(Q source, C0189j mediator) {
+        Intrinsics.checkNotNullParameter(source, "source");
+        Intrinsics.checkNotNullParameter(mediator, "mediator");
+        this.f3421a = source;
+        this.f3422b = mediator;
+    }
+
+    @Override // kotlinx.coroutines.DisposableHandle
+    public final void dispose() {
+        BuildersKt__Builders_commonKt.launch$default(CoroutineScopeKt.CoroutineScope(Dispatchers.getMain().getImmediate()), null, null, new C0195p(this, null), 3, null);
+    }
+}

apk_decompiled/sources/androidx/lifecycle/r0.java

@@ -0,0 +1,72 @@
+package androidx.lifecycle;
+
+import android.os.Bundle;
+import java.util.Map;
+import kotlin.Lazy;
+import kotlin.LazyKt;
+import kotlin.jvm.internal.Intrinsics;
+import v0.C0639d;
+import v0.InterfaceC0638c;
+
+/* loaded from: classes.dex */
+public final class r0 implements InterfaceC0638c {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final C0639d f3424a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public boolean f3425b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public Bundle f3426c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final Lazy f3427d;
+
+    public r0(C0639d savedStateRegistry, D0 viewModelStoreOwner) {
+        Intrinsics.checkNotNullParameter(savedStateRegistry, "savedStateRegistry");
+        Intrinsics.checkNotNullParameter(viewModelStoreOwner, "viewModelStoreOwner");
+        this.f3424a = savedStateRegistry;
+        this.f3427d = LazyKt.lazy(new J0.e(viewModelStoreOwner, 3));
+    }
+
+    @Override // v0.InterfaceC0638c
+    public final Bundle a() {
+        Bundle bundle = new Bundle();
+        Bundle bundle2 = this.f3426c;
+        if (bundle2 != null) {
+            bundle.putAll(bundle2);
+        }
+        for (Map.Entry entry : b().f3428a.entrySet()) {
+            String str = (String) entry.getKey();
+            Bundle a2 = ((n0) entry.getValue()).f3408e.a();
+            if (!Intrinsics.areEqual(a2, Bundle.EMPTY)) {
+                bundle.putBundle(str, a2);
+            }
+        }
+        this.f3425b = false;
+        return bundle;
+    }
+
+    public final s0 b() {
+        return (s0) this.f3427d.getValue();
+    }
+
+    public final void c() {
+        if (this.f3425b) {
+            return;
+        }
+        Bundle a2 = this.f3424a.a("androidx.lifecycle.internal.SavedStateHandlesProvider");
+        Bundle bundle = new Bundle();
+        Bundle bundle2 = this.f3426c;
+        if (bundle2 != null) {
+            bundle.putAll(bundle2);
+        }
+        if (a2 != null) {
+            bundle.putAll(a2);
+        }
+        this.f3426c = bundle;
+        this.f3425b = true;
+        b();
+    }
+}

apk_decompiled/sources/androidx/lifecycle/s0.java

@@ -0,0 +1,10 @@
+package androidx.lifecycle;
+
+import java.util.LinkedHashMap;
+
+/* loaded from: classes.dex */
+public final class s0 extends w0 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final LinkedHashMap f3428a = new LinkedHashMap();
+}

apk_decompiled/sources/androidx/lifecycle/t0.java

@@ -0,0 +1,138 @@
+package androidx.lifecycle;
+
+import android.app.Application;
+import android.os.Bundle;
+import java.lang.reflect.Constructor;
+import kotlin.jvm.internal.Intrinsics;
+import m0.C0503c;
+import v0.C0639d;
+
+/* loaded from: classes.dex */
+public final class t0 extends A0 implements y0 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Application f3432a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final x0 f3433b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final Bundle f3434c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final C f3435d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final C0639d f3436e;
+
+    public t0(Application application, v0.f owner, Bundle bundle) {
+        x0 x0Var;
+        Intrinsics.checkNotNullParameter(owner, "owner");
+        this.f3436e = owner.getSavedStateRegistry();
+        this.f3435d = owner.getLifecycle();
+        this.f3434c = bundle;
+        this.f3432a = application;
+        if (application != null) {
+            Intrinsics.checkNotNullParameter(application, "application");
+            if (x0.f3439c == null) {
+                Intrinsics.checkNotNullParameter(application, "application");
+                x0.f3439c = new x0(application);
+            }
+            x0Var = x0.f3439c;
+            Intrinsics.checkNotNull(x0Var);
+        } else {
+            x0Var = new x0(null);
+        }
+        this.f3433b = x0Var;
+    }
+
+    @Override // androidx.lifecycle.A0
+    public final void a(w0 viewModel) {
+        Intrinsics.checkNotNullParameter(viewModel, "viewModel");
+        C c4 = this.f3435d;
+        if (c4 != null) {
+            C0639d c0639d = this.f3436e;
+            Intrinsics.checkNotNull(c0639d);
+            Intrinsics.checkNotNull(c4);
+            q0.b(viewModel, c0639d, c4);
+        }
+    }
+
+    /* JADX WARN: Type inference failed for: r5v7, types: [androidx.lifecycle.z0, java.lang.Object] */
+    public final w0 b(Class modelClass, String key) {
+        w0 b4;
+        Intrinsics.checkNotNullParameter(key, "key");
+        Intrinsics.checkNotNullParameter(modelClass, "modelClass");
+        C c4 = this.f3435d;
+        if (c4 == null) {
+            throw new UnsupportedOperationException("SavedStateViewModelFactory constructed with empty constructor supports only calls to create(modelClass: Class<T>, extras: CreationExtras).");
+        }
+        boolean isAssignableFrom = AbstractC0176a.class.isAssignableFrom(modelClass);
+        Application application = this.f3432a;
+        Constructor a2 = (!isAssignableFrom || application == null) ? u0.a(modelClass, u0.f3438b) : u0.a(modelClass, u0.f3437a);
+        if (a2 == null) {
+            if (application != null) {
+                return this.f3433b.create(modelClass);
+            }
+            if (z0.f3442a == null) {
+                z0.f3442a = new Object();
+            }
+            z0 z0Var = z0.f3442a;
+            Intrinsics.checkNotNull(z0Var);
+            return z0Var.create(modelClass);
+        }
+        C0639d c0639d = this.f3436e;
+        Intrinsics.checkNotNull(c0639d);
+        o0 c5 = q0.c(c0639d, c4, key, this.f3434c);
+        n0 n0Var = c5.f3413b;
+        if (!isAssignableFrom || application == null) {
+            b4 = u0.b(modelClass, a2, n0Var);
+        } else {
+            Intrinsics.checkNotNull(application);
+            b4 = u0.b(modelClass, a2, application, n0Var);
+        }
+        b4.addCloseable("androidx.lifecycle.savedstate.vm.tag", c5);
+        return b4;
+    }
+
+    @Override // androidx.lifecycle.y0
+    public final w0 create(Class modelClass, l0.c extras) {
+        Constructor a2;
+        Intrinsics.checkNotNullParameter(modelClass, "modelClass");
+        Intrinsics.checkNotNullParameter(extras, "extras");
+        String str = (String) extras.a(C0503c.f7792a);
+        if (str != null) {
+            if (extras.a(q0.f3417a) != null && extras.a(q0.f3418b) != null) {
+                Application application = (Application) extras.a(x0.f3440d);
+                boolean isAssignableFrom = AbstractC0176a.class.isAssignableFrom(modelClass);
+                if (isAssignableFrom && application != null) {
+                    a2 = u0.a(modelClass, u0.f3437a);
+                } else {
+                    a2 = u0.a(modelClass, u0.f3438b);
+                }
+                if (a2 == null) {
+                    return this.f3433b.create(modelClass, extras);
+                }
+                if (isAssignableFrom && application != null) {
+                    return u0.b(modelClass, a2, application, q0.e(extras));
+                }
+                return u0.b(modelClass, a2, q0.e(extras));
+            }
+            if (this.f3435d != null) {
+                return b(modelClass, str);
+            }
+            throw new IllegalStateException("SAVED_STATE_REGISTRY_OWNER_KEY andVIEW_MODEL_STORE_OWNER_KEY must be provided in the creation extras tosuccessfully create a ViewModel.");
+        }
+        throw new IllegalStateException("VIEW_MODEL_KEY must always be provided by ViewModelProvider");
+    }
+
+    @Override // androidx.lifecycle.y0
+    public final w0 create(Class modelClass) {
+        Intrinsics.checkNotNullParameter(modelClass, "modelClass");
+        String canonicalName = modelClass.getCanonicalName();
+        if (canonicalName != null) {
+            return b(modelClass, canonicalName);
+        }
+        throw new IllegalArgumentException("Local and anonymous classes can not be ViewModels");
+    }
+}

apk_decompiled/sources/androidx/lifecycle/u0.java

@@ -0,0 +1,55 @@
+package androidx.lifecycle;
+
+import android.app.Application;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Arrays;
+import java.util.List;
+import kotlin.collections.ArraysKt;
+import kotlin.collections.CollectionsKt;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public abstract class u0 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final List f3437a = CollectionsKt.listOf((Object[]) new Class[]{Application.class, n0.class});
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final List f3438b = CollectionsKt.listOf(n0.class);
+
+    public static final Constructor a(Class modelClass, List signature) {
+        Intrinsics.checkNotNullParameter(modelClass, "modelClass");
+        Intrinsics.checkNotNullParameter(signature, "signature");
+        Constructor<?>[] constructors = modelClass.getConstructors();
+        Intrinsics.checkNotNullExpressionValue(constructors, "modelClass.constructors");
+        for (Constructor<?> constructor : constructors) {
+            Class<?>[] parameterTypes = constructor.getParameterTypes();
+            Intrinsics.checkNotNullExpressionValue(parameterTypes, "constructor.parameterTypes");
+            List list = ArraysKt.toList(parameterTypes);
+            if (Intrinsics.areEqual(signature, list)) {
+                Intrinsics.checkNotNull(constructor, "null cannot be cast to non-null type java.lang.reflect.Constructor<T of androidx.lifecycle.SavedStateViewModelFactoryKt.findMatchingConstructor>");
+                return constructor;
+            }
+            if (signature.size() == list.size() && list.containsAll(signature)) {
+                throw new UnsupportedOperationException("Class " + modelClass.getSimpleName() + " must have parameters in the proper order: " + signature);
+            }
+        }
+        return null;
+    }
+
+    public static final w0 b(Class modelClass, Constructor constructor, Object... params) {
+        Intrinsics.checkNotNullParameter(modelClass, "modelClass");
+        Intrinsics.checkNotNullParameter(constructor, "constructor");
+        Intrinsics.checkNotNullParameter(params, "params");
+        try {
+            return (w0) constructor.newInstance(Arrays.copyOf(params, params.length));
+        } catch (IllegalAccessException e4) {
+            throw new RuntimeException("Failed to access " + modelClass, e4);
+        } catch (InstantiationException e5) {
+            throw new RuntimeException("A " + modelClass + " cannot be instantiated.", e5);
+        } catch (InvocationTargetException e6) {
+            throw new RuntimeException("An exception happened in constructor of " + modelClass, e6.getCause());
+        }
+    }
+}

apk_decompiled/sources/androidx/lifecycle/v0.java

@@ -0,0 +1,13 @@
+package androidx.lifecycle;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class v0 implements H {
+    @Override // androidx.lifecycle.H
+    public final void onStateChanged(J source, A event) {
+        Intrinsics.checkNotNullParameter(source, "source");
+        Intrinsics.checkNotNullParameter(event, "event");
+        throw null;
+    }
+}

apk_decompiled/sources/androidx/lifecycle/w0.java

@@ -0,0 +1,91 @@
+package androidx.lifecycle;
+
+import java.io.Closeable;
+import java.util.Iterator;
+import kotlin.Deprecated;
+import kotlin.DeprecationLevel;
+import kotlin.Unit;
+import kotlin.jvm.internal.Intrinsics;
+import m0.C0502b;
+
+/* loaded from: classes.dex */
+public abstract class w0 {
+    private final C0502b impl = new C0502b();
+
+    public final void addCloseable(String key, AutoCloseable closeable) {
+        AutoCloseable autoCloseable;
+        Intrinsics.checkNotNullParameter(key, "key");
+        Intrinsics.checkNotNullParameter(closeable, "closeable");
+        C0502b c0502b = this.impl;
+        if (c0502b != null) {
+            Intrinsics.checkNotNullParameter(key, "key");
+            Intrinsics.checkNotNullParameter(closeable, "closeable");
+            if (c0502b.f7791d) {
+                C0502b.b(closeable);
+                return;
+            }
+            synchronized (c0502b.f7788a) {
+                autoCloseable = (AutoCloseable) c0502b.f7789b.put(key, closeable);
+            }
+            C0502b.b(autoCloseable);
+        }
+    }
+
+    public final void clear$lifecycle_viewmodel_release() {
+        C0502b c0502b = this.impl;
+        if (c0502b != null && !c0502b.f7791d) {
+            c0502b.f7791d = true;
+            synchronized (c0502b.f7788a) {
+                try {
+                    Iterator it = c0502b.f7789b.values().iterator();
+                    while (it.hasNext()) {
+                        C0502b.b((AutoCloseable) it.next());
+                    }
+                    Iterator it2 = c0502b.f7790c.iterator();
+                    while (it2.hasNext()) {
+                        C0502b.b((AutoCloseable) it2.next());
+                    }
+                    c0502b.f7790c.clear();
+                    Unit unit = Unit.INSTANCE;
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        }
+        onCleared();
+    }
+
+    public final <T extends AutoCloseable> T getCloseable(String key) {
+        T t2;
+        Intrinsics.checkNotNullParameter(key, "key");
+        C0502b c0502b = this.impl;
+        if (c0502b == null) {
+            return null;
+        }
+        Intrinsics.checkNotNullParameter(key, "key");
+        synchronized (c0502b.f7788a) {
+            t2 = (T) c0502b.f7789b.get(key);
+        }
+        return t2;
+    }
+
+    public void onCleared() {
+    }
+
+    public void addCloseable(AutoCloseable closeable) {
+        Intrinsics.checkNotNullParameter(closeable, "closeable");
+        C0502b c0502b = this.impl;
+        if (c0502b != null) {
+            c0502b.a(closeable);
+        }
+    }
+
+    @Deprecated(level = DeprecationLevel.HIDDEN, message = "Replaced by `AutoCloseable` overload.")
+    public /* synthetic */ void addCloseable(Closeable closeable) {
+        Intrinsics.checkNotNullParameter(closeable, "closeable");
+        C0502b c0502b = this.impl;
+        if (c0502b != null) {
+            c0502b.a(closeable);
+        }
+    }
+}

apk_decompiled/sources/androidx/lifecycle/x0.java

@@ -0,0 +1,68 @@
+package androidx.lifecycle;
+
+import android.app.Application;
+import java.lang.reflect.InvocationTargetException;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class x0 extends z0 {
+
+    /* renamed from: c, reason: collision with root package name */
+    public static x0 f3439c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public static final E2.e f3440d = new E2.e(25);
+
+    /* renamed from: b, reason: collision with root package name */
+    public final Application f3441b;
+
+    public x0(Application application) {
+        this.f3441b = application;
+    }
+
+    public final w0 a(Class cls, Application application) {
+        if (!AbstractC0176a.class.isAssignableFrom(cls)) {
+            return super.create(cls);
+        }
+        try {
+            w0 w0Var = (w0) cls.getConstructor(Application.class).newInstance(application);
+            Intrinsics.checkNotNullExpressionValue(w0Var, "{\n                try {\n…          }\n            }");
+            return w0Var;
+        } catch (IllegalAccessException e4) {
+            throw new RuntimeException("Cannot create an instance of " + cls, e4);
+        } catch (InstantiationException e5) {
+            throw new RuntimeException("Cannot create an instance of " + cls, e5);
+        } catch (NoSuchMethodException e6) {
+            throw new RuntimeException("Cannot create an instance of " + cls, e6);
+        } catch (InvocationTargetException e7) {
+            throw new RuntimeException("Cannot create an instance of " + cls, e7);
+        }
+    }
+
+    @Override // androidx.lifecycle.z0, androidx.lifecycle.y0
+    public final w0 create(Class modelClass, l0.c extras) {
+        Intrinsics.checkNotNullParameter(modelClass, "modelClass");
+        Intrinsics.checkNotNullParameter(extras, "extras");
+        if (this.f3441b != null) {
+            return create(modelClass);
+        }
+        Application application = (Application) extras.a(f3440d);
+        if (application != null) {
+            return a(modelClass, application);
+        }
+        if (!AbstractC0176a.class.isAssignableFrom(modelClass)) {
+            return super.create(modelClass);
+        }
+        throw new IllegalArgumentException("CreationExtras must have an application by `APPLICATION_KEY`");
+    }
+
+    @Override // androidx.lifecycle.z0, androidx.lifecycle.y0
+    public final w0 create(Class modelClass) {
+        Intrinsics.checkNotNullParameter(modelClass, "modelClass");
+        Application application = this.f3441b;
+        if (application != null) {
+            return a(modelClass, application);
+        }
+        throw new UnsupportedOperationException("AndroidViewModelFactory constructed with empty constructor works only with create(modelClass: Class<T>, extras: CreationExtras).");
+    }
+}

apk_decompiled/sources/androidx/lifecycle/y0.java

@@ -0,0 +1,25 @@
+package androidx.lifecycle;
+
+import kotlin.jvm.JvmClassMappingKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.reflect.KClass;
+
+/* loaded from: classes.dex */
+public interface y0 {
+    default w0 create(Class modelClass) {
+        Intrinsics.checkNotNullParameter(modelClass, "modelClass");
+        throw new UnsupportedOperationException("`Factory.create(String, CreationExtras)` is not implemented. You may need to override the method and provide a custom implementation. Note that using `Factory.create(String)` is not supported and considered an error.");
+    }
+
+    default w0 create(Class modelClass, l0.c extras) {
+        Intrinsics.checkNotNullParameter(modelClass, "modelClass");
+        Intrinsics.checkNotNullParameter(extras, "extras");
+        return create(modelClass);
+    }
+
+    default w0 create(KClass modelClass, l0.c extras) {
+        Intrinsics.checkNotNullParameter(modelClass, "modelClass");
+        Intrinsics.checkNotNullParameter(extras, "extras");
+        return create(JvmClassMappingKt.getJavaClass(modelClass), extras);
+    }
+}

apk_decompiled/sources/androidx/lifecycle/z0.java

@@ -0,0 +1,43 @@
+package androidx.lifecycle;
+
+import kotlin.jvm.JvmClassMappingKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.reflect.KClass;
+
+/* loaded from: classes.dex */
+public class z0 implements y0 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static z0 f3442a;
+
+    @Override // androidx.lifecycle.y0
+    public w0 create(Class modelClass) {
+        Intrinsics.checkNotNullParameter(modelClass, "modelClass");
+        Intrinsics.checkNotNullParameter(modelClass, "modelClass");
+        try {
+            Object newInstance = modelClass.getDeclaredConstructor(new Class[0]).newInstance(new Object[0]);
+            Intrinsics.checkNotNullExpressionValue(newInstance, "{\n            modelClass…).newInstance()\n        }");
+            return (w0) newInstance;
+        } catch (IllegalAccessException e4) {
+            throw new RuntimeException("Cannot create an instance of " + modelClass, e4);
+        } catch (InstantiationException e5) {
+            throw new RuntimeException("Cannot create an instance of " + modelClass, e5);
+        } catch (NoSuchMethodException e6) {
+            throw new RuntimeException("Cannot create an instance of " + modelClass, e6);
+        }
+    }
+
+    @Override // androidx.lifecycle.y0
+    public w0 create(Class modelClass, l0.c extras) {
+        Intrinsics.checkNotNullParameter(modelClass, "modelClass");
+        Intrinsics.checkNotNullParameter(extras, "extras");
+        return create(modelClass);
+    }
+
+    @Override // androidx.lifecycle.y0
+    public final w0 create(KClass modelClass, l0.c extras) {
+        Intrinsics.checkNotNullParameter(modelClass, "modelClass");
+        Intrinsics.checkNotNullParameter(extras, "extras");
+        return create(JvmClassMappingKt.getJavaClass(modelClass), extras);
+    }
+}