Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/kotlin/coroutines/AbstractCoroutineContextElement.java

@@ -0,0 +1,40 @@
+package kotlin.coroutines;
+
+import kotlin.coroutines.CoroutineContext;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class AbstractCoroutineContextElement implements CoroutineContext.Element {
+    private final CoroutineContext.Key key;
+
+    @Override // kotlin.coroutines.CoroutineContext.Element
+    public CoroutineContext.Key getKey() {
+        return this.key;
+    }
+
+    public AbstractCoroutineContextElement(CoroutineContext.Key key) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        this.key = key;
+    }
+
+    @Override // kotlin.coroutines.CoroutineContext
+    public <R> R fold(R r, Function2 function2) {
+        return (R) CoroutineContext.Element.DefaultImpls.fold(this, r, function2);
+    }
+
+    @Override // kotlin.coroutines.CoroutineContext.Element, kotlin.coroutines.CoroutineContext
+    public <E extends CoroutineContext.Element> E get(CoroutineContext.Key key) {
+        return (E) CoroutineContext.Element.DefaultImpls.get(this, key);
+    }
+
+    @Override // kotlin.coroutines.CoroutineContext
+    public CoroutineContext minusKey(CoroutineContext.Key key) {
+        return CoroutineContext.Element.DefaultImpls.minusKey(this, key);
+    }
+
+    @Override // kotlin.coroutines.CoroutineContext
+    public CoroutineContext plus(CoroutineContext coroutineContext) {
+        return CoroutineContext.Element.DefaultImpls.plus(this, coroutineContext);
+    }
+}

decompiled/sources/kotlin/coroutines/AbstractCoroutineContextKey.java

@@ -0,0 +1,28 @@
+package kotlin.coroutines;
+
+import kotlin.coroutines.CoroutineContext;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class AbstractCoroutineContextKey implements CoroutineContext.Key {
+    public final Function1 safeCast;
+    public final CoroutineContext.Key topmostKey;
+
+    public final boolean isSubKey$kotlin_stdlib(CoroutineContext.Key key) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        return key == this || this.topmostKey == key;
+    }
+
+    public AbstractCoroutineContextKey(CoroutineContext.Key baseKey, Function1 safeCast) {
+        Intrinsics.checkNotNullParameter(baseKey, "baseKey");
+        Intrinsics.checkNotNullParameter(safeCast, "safeCast");
+        this.safeCast = safeCast;
+        this.topmostKey = baseKey instanceof AbstractCoroutineContextKey ? ((AbstractCoroutineContextKey) baseKey).topmostKey : baseKey;
+    }
+
+    public final CoroutineContext.Element tryCast$kotlin_stdlib(CoroutineContext.Element element) {
+        Intrinsics.checkNotNullParameter(element, "element");
+        return (CoroutineContext.Element) this.safeCast.invoke(element);
+    }
+}

decompiled/sources/kotlin/coroutines/CombinedContext.java

@@ -0,0 +1,182 @@
+package kotlin.coroutines;
+
+import java.io.Serializable;
+import kotlin.Unit;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Ref;
+
+/* loaded from: classes5.dex */
+public final class CombinedContext implements CoroutineContext, Serializable {
+    public final CoroutineContext.Element element;
+    public final CoroutineContext left;
+
+    public CombinedContext(CoroutineContext left, CoroutineContext.Element element) {
+        Intrinsics.checkNotNullParameter(left, "left");
+        Intrinsics.checkNotNullParameter(element, "element");
+        this.left = left;
+        this.element = element;
+    }
+
+    @Override // kotlin.coroutines.CoroutineContext
+    public CoroutineContext plus(CoroutineContext coroutineContext) {
+        return CoroutineContext.DefaultImpls.plus(this, coroutineContext);
+    }
+
+    @Override // kotlin.coroutines.CoroutineContext
+    public CoroutineContext.Element get(CoroutineContext.Key key) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        CombinedContext combinedContext = this;
+        while (true) {
+            CoroutineContext.Element element = combinedContext.element.get(key);
+            if (element != null) {
+                return element;
+            }
+            CoroutineContext coroutineContext = combinedContext.left;
+            if (coroutineContext instanceof CombinedContext) {
+                combinedContext = (CombinedContext) coroutineContext;
+            } else {
+                return coroutineContext.get(key);
+            }
+        }
+    }
+
+    @Override // kotlin.coroutines.CoroutineContext
+    public Object fold(Object obj, Function2 operation) {
+        Intrinsics.checkNotNullParameter(operation, "operation");
+        return operation.invoke(this.left.fold(obj, operation), this.element);
+    }
+
+    @Override // kotlin.coroutines.CoroutineContext
+    public CoroutineContext minusKey(CoroutineContext.Key key) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        if (this.element.get(key) != null) {
+            return this.left;
+        }
+        CoroutineContext minusKey = this.left.minusKey(key);
+        return minusKey == this.left ? this : minusKey == EmptyCoroutineContext.INSTANCE ? this.element : new CombinedContext(minusKey, this.element);
+    }
+
+    private final int size() {
+        int i = 2;
+        CombinedContext combinedContext = this;
+        while (true) {
+            CoroutineContext coroutineContext = combinedContext.left;
+            combinedContext = coroutineContext instanceof CombinedContext ? (CombinedContext) coroutineContext : null;
+            if (combinedContext == null) {
+                return i;
+            }
+            i++;
+        }
+    }
+
+    public final boolean contains(CoroutineContext.Element element) {
+        return Intrinsics.areEqual(get(element.getKey()), element);
+    }
+
+    public final boolean containsAll(CombinedContext combinedContext) {
+        while (contains(combinedContext.element)) {
+            CoroutineContext coroutineContext = combinedContext.left;
+            if (coroutineContext instanceof CombinedContext) {
+                combinedContext = (CombinedContext) coroutineContext;
+            } else {
+                Intrinsics.checkNotNull(coroutineContext, "null cannot be cast to non-null type kotlin.coroutines.CoroutineContext.Element");
+                return contains((CoroutineContext.Element) coroutineContext);
+            }
+        }
+        return false;
+    }
+
+    public boolean equals(Object obj) {
+        if (this != obj) {
+            if (obj instanceof CombinedContext) {
+                CombinedContext combinedContext = (CombinedContext) obj;
+                if (combinedContext.size() != size() || !combinedContext.containsAll(this)) {
+                }
+            }
+            return false;
+        }
+        return true;
+    }
+
+    public int hashCode() {
+        return this.left.hashCode() + this.element.hashCode();
+    }
+
+    public String toString() {
+        return '[' + ((String) fold("", new Function2() { // from class: kotlin.coroutines.CombinedContext$toString$1
+            @Override // kotlin.jvm.functions.Function2
+            public final String invoke(String acc, CoroutineContext.Element element) {
+                Intrinsics.checkNotNullParameter(acc, "acc");
+                Intrinsics.checkNotNullParameter(element, "element");
+                if (acc.length() == 0) {
+                    return element.toString();
+                }
+                return acc + ", " + element;
+            }
+        })) + ']';
+    }
+
+    private final Object writeReplace() {
+        int size = size();
+        final CoroutineContext[] coroutineContextArr = new CoroutineContext[size];
+        final Ref.IntRef intRef = new Ref.IntRef();
+        fold(Unit.INSTANCE, new Function2() { // from class: kotlin.coroutines.CombinedContext$writeReplace$1
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(2);
+            }
+
+            @Override // kotlin.jvm.functions.Function2
+            public /* bridge */ /* synthetic */ Object invoke(Object obj, Object obj2) {
+                invoke((Unit) obj, (CoroutineContext.Element) obj2);
+                return Unit.INSTANCE;
+            }
+
+            public final void invoke(Unit unit, CoroutineContext.Element element) {
+                Intrinsics.checkNotNullParameter(unit, "<anonymous parameter 0>");
+                Intrinsics.checkNotNullParameter(element, "element");
+                CoroutineContext[] coroutineContextArr2 = coroutineContextArr;
+                Ref.IntRef intRef2 = intRef;
+                int i = intRef2.element;
+                intRef2.element = i + 1;
+                coroutineContextArr2[i] = element;
+            }
+        });
+        if (intRef.element != size) {
+            throw new IllegalStateException("Check failed.".toString());
+        }
+        return new Serialized(coroutineContextArr);
+    }
+
+    public static final class Serialized implements Serializable {
+        public static final Companion Companion = new Companion(null);
+        private static final long serialVersionUID = 0;
+        public final CoroutineContext[] elements;
+
+        public static final class Companion {
+            public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+                this();
+            }
+
+            public Companion() {
+            }
+        }
+
+        public Serialized(CoroutineContext[] elements) {
+            Intrinsics.checkNotNullParameter(elements, "elements");
+            this.elements = elements;
+        }
+
+        private final Object readResolve() {
+            CoroutineContext[] coroutineContextArr = this.elements;
+            CoroutineContext coroutineContext = EmptyCoroutineContext.INSTANCE;
+            for (CoroutineContext coroutineContext2 : coroutineContextArr) {
+                coroutineContext = coroutineContext.plus(coroutineContext2);
+            }
+            return coroutineContext;
+        }
+    }
+}

decompiled/sources/kotlin/coroutines/Continuation.java

@@ -0,0 +1,8 @@
+package kotlin.coroutines;
+
+/* loaded from: classes5.dex */
+public interface Continuation {
+    CoroutineContext getContext();
+
+    void resumeWith(Object obj);
+}

decompiled/sources/kotlin/coroutines/ContinuationInterceptor.java

@@ -0,0 +1,48 @@
+package kotlin.coroutines;
+
+import kotlin.coroutines.CoroutineContext;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public interface ContinuationInterceptor extends CoroutineContext.Element {
+    public static final Key Key = Key.$$INSTANCE;
+
+    public static final class Key implements CoroutineContext.Key {
+        public static final /* synthetic */ Key $$INSTANCE = new Key();
+    }
+
+    Continuation interceptContinuation(Continuation continuation);
+
+    void releaseInterceptedContinuation(Continuation continuation);
+
+    public static final class DefaultImpls {
+        public static CoroutineContext.Element get(ContinuationInterceptor continuationInterceptor, CoroutineContext.Key key) {
+            Intrinsics.checkNotNullParameter(key, "key");
+            if (key instanceof AbstractCoroutineContextKey) {
+                AbstractCoroutineContextKey abstractCoroutineContextKey = (AbstractCoroutineContextKey) key;
+                if (!abstractCoroutineContextKey.isSubKey$kotlin_stdlib(continuationInterceptor.getKey())) {
+                    return null;
+                }
+                CoroutineContext.Element tryCast$kotlin_stdlib = abstractCoroutineContextKey.tryCast$kotlin_stdlib(continuationInterceptor);
+                if (tryCast$kotlin_stdlib instanceof CoroutineContext.Element) {
+                    return tryCast$kotlin_stdlib;
+                }
+                return null;
+            }
+            if (ContinuationInterceptor.Key != key) {
+                return null;
+            }
+            Intrinsics.checkNotNull(continuationInterceptor, "null cannot be cast to non-null type E of kotlin.coroutines.ContinuationInterceptor.get");
+            return continuationInterceptor;
+        }
+
+        public static CoroutineContext minusKey(ContinuationInterceptor continuationInterceptor, CoroutineContext.Key key) {
+            Intrinsics.checkNotNullParameter(key, "key");
+            if (!(key instanceof AbstractCoroutineContextKey)) {
+                return ContinuationInterceptor.Key == key ? EmptyCoroutineContext.INSTANCE : continuationInterceptor;
+            }
+            AbstractCoroutineContextKey abstractCoroutineContextKey = (AbstractCoroutineContextKey) key;
+            return (!abstractCoroutineContextKey.isSubKey$kotlin_stdlib(continuationInterceptor.getKey()) || abstractCoroutineContextKey.tryCast$kotlin_stdlib(continuationInterceptor) == null) ? continuationInterceptor : EmptyCoroutineContext.INSTANCE;
+        }
+    }
+}

decompiled/sources/kotlin/coroutines/ContinuationKt.java

@@ -0,0 +1,33 @@
+package kotlin.coroutines;
+
+import kotlin.Result;
+import kotlin.Unit;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class ContinuationKt {
+    public static final void startCoroutine(Function1 function1, Continuation completion) {
+        Continuation createCoroutineUnintercepted;
+        Continuation intercepted;
+        Intrinsics.checkNotNullParameter(function1, "<this>");
+        Intrinsics.checkNotNullParameter(completion, "completion");
+        createCoroutineUnintercepted = IntrinsicsKt__IntrinsicsJvmKt.createCoroutineUnintercepted(function1, completion);
+        intercepted = IntrinsicsKt__IntrinsicsJvmKt.intercepted(createCoroutineUnintercepted);
+        Result.Companion companion = Result.Companion;
+        intercepted.resumeWith(Result.m4060constructorimpl(Unit.INSTANCE));
+    }
+
+    public static final void startCoroutine(Function2 function2, Object obj, Continuation completion) {
+        Continuation createCoroutineUnintercepted;
+        Continuation intercepted;
+        Intrinsics.checkNotNullParameter(function2, "<this>");
+        Intrinsics.checkNotNullParameter(completion, "completion");
+        createCoroutineUnintercepted = IntrinsicsKt__IntrinsicsJvmKt.createCoroutineUnintercepted(function2, obj, completion);
+        intercepted = IntrinsicsKt__IntrinsicsJvmKt.intercepted(createCoroutineUnintercepted);
+        Result.Companion companion = Result.Companion;
+        intercepted.resumeWith(Result.m4060constructorimpl(Unit.INSTANCE));
+    }
+}

decompiled/sources/kotlin/coroutines/CoroutineContext.java

@@ -0,0 +1,85 @@
+package kotlin.coroutines;
+
+import kotlin.coroutines.ContinuationInterceptor;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public interface CoroutineContext {
+
+    public interface Key {
+    }
+
+    Object fold(Object obj, Function2 function2);
+
+    Element get(Key key);
+
+    CoroutineContext minusKey(Key key);
+
+    CoroutineContext plus(CoroutineContext coroutineContext);
+
+    public static final class DefaultImpls {
+        public static CoroutineContext plus(CoroutineContext coroutineContext, CoroutineContext context) {
+            Intrinsics.checkNotNullParameter(context, "context");
+            return context == EmptyCoroutineContext.INSTANCE ? coroutineContext : (CoroutineContext) context.fold(coroutineContext, new Function2() { // from class: kotlin.coroutines.CoroutineContext$plus$1
+                @Override // kotlin.jvm.functions.Function2
+                public final CoroutineContext invoke(CoroutineContext acc, CoroutineContext.Element element) {
+                    CombinedContext combinedContext;
+                    Intrinsics.checkNotNullParameter(acc, "acc");
+                    Intrinsics.checkNotNullParameter(element, "element");
+                    CoroutineContext minusKey = acc.minusKey(element.getKey());
+                    EmptyCoroutineContext emptyCoroutineContext = EmptyCoroutineContext.INSTANCE;
+                    if (minusKey == emptyCoroutineContext) {
+                        return element;
+                    }
+                    ContinuationInterceptor.Key key = ContinuationInterceptor.Key;
+                    ContinuationInterceptor continuationInterceptor = (ContinuationInterceptor) minusKey.get(key);
+                    if (continuationInterceptor == null) {
+                        combinedContext = new CombinedContext(minusKey, element);
+                    } else {
+                        CoroutineContext minusKey2 = minusKey.minusKey(key);
+                        if (minusKey2 == emptyCoroutineContext) {
+                            return new CombinedContext(element, continuationInterceptor);
+                        }
+                        combinedContext = new CombinedContext(new CombinedContext(minusKey2, element), continuationInterceptor);
+                    }
+                    return combinedContext;
+                }
+            });
+        }
+    }
+
+    public interface Element extends CoroutineContext {
+        @Override // kotlin.coroutines.CoroutineContext
+        Element get(Key key);
+
+        Key getKey();
+
+        public static final class DefaultImpls {
+            public static CoroutineContext plus(Element element, CoroutineContext context) {
+                Intrinsics.checkNotNullParameter(context, "context");
+                return DefaultImpls.plus(element, context);
+            }
+
+            public static Element get(Element element, Key key) {
+                Intrinsics.checkNotNullParameter(key, "key");
+                if (!Intrinsics.areEqual(element.getKey(), key)) {
+                    return null;
+                }
+                Intrinsics.checkNotNull(element, "null cannot be cast to non-null type E of kotlin.coroutines.CoroutineContext.Element.get");
+                return element;
+            }
+
+            public static Object fold(Element element, Object obj, Function2 operation) {
+                Intrinsics.checkNotNullParameter(operation, "operation");
+                return operation.invoke(obj, element);
+            }
+
+            public static CoroutineContext minusKey(Element element, Key key) {
+                Intrinsics.checkNotNullParameter(key, "key");
+                return Intrinsics.areEqual(element.getKey(), key) ? EmptyCoroutineContext.INSTANCE : element;
+            }
+        }
+    }
+}

decompiled/sources/kotlin/coroutines/EmptyCoroutineContext.java

@@ -0,0 +1,48 @@
+package kotlin.coroutines;
+
+import java.io.Serializable;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class EmptyCoroutineContext implements CoroutineContext, Serializable {
+    public static final EmptyCoroutineContext INSTANCE = new EmptyCoroutineContext();
+    private static final long serialVersionUID = 0;
+
+    private final Object readResolve() {
+        return INSTANCE;
+    }
+
+    @Override // kotlin.coroutines.CoroutineContext
+    public Object fold(Object obj, Function2 operation) {
+        Intrinsics.checkNotNullParameter(operation, "operation");
+        return obj;
+    }
+
+    @Override // kotlin.coroutines.CoroutineContext
+    public CoroutineContext.Element get(CoroutineContext.Key key) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        return null;
+    }
+
+    public int hashCode() {
+        return 0;
+    }
+
+    @Override // kotlin.coroutines.CoroutineContext
+    public CoroutineContext minusKey(CoroutineContext.Key key) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        return this;
+    }
+
+    @Override // kotlin.coroutines.CoroutineContext
+    public CoroutineContext plus(CoroutineContext context) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        return context;
+    }
+
+    public String toString() {
+        return "EmptyCoroutineContext";
+    }
+}

decompiled/sources/kotlin/coroutines/SafeContinuation.java

@@ -0,0 +1,106 @@
+package kotlin.coroutines;
+
+import androidx.concurrent.futures.AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0;
+import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
+import kotlin.Result;
+import kotlin.coroutines.intrinsics.CoroutineSingletons;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.CoroutineStackFrame;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class SafeContinuation implements Continuation, CoroutineStackFrame {
+    public static final Companion Companion = new Companion(null);
+    public static final AtomicReferenceFieldUpdater RESULT = AtomicReferenceFieldUpdater.newUpdater(SafeContinuation.class, Object.class, "result");
+    public final Continuation delegate;
+    private volatile Object result;
+
+    public SafeContinuation(Continuation delegate, Object obj) {
+        Intrinsics.checkNotNullParameter(delegate, "delegate");
+        this.delegate = delegate;
+        this.result = obj;
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public SafeContinuation(Continuation delegate) {
+        this(delegate, CoroutineSingletons.UNDECIDED);
+        Intrinsics.checkNotNullParameter(delegate, "delegate");
+    }
+
+    @Override // kotlin.coroutines.Continuation
+    public CoroutineContext getContext() {
+        return this.delegate.getContext();
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+
+    @Override // kotlin.coroutines.Continuation
+    public void resumeWith(Object obj) {
+        Object coroutine_suspended;
+        Object coroutine_suspended2;
+        while (true) {
+            Object obj2 = this.result;
+            CoroutineSingletons coroutineSingletons = CoroutineSingletons.UNDECIDED;
+            if (obj2 != coroutineSingletons) {
+                coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+                if (obj2 != coroutine_suspended) {
+                    throw new IllegalStateException("Already resumed");
+                }
+                AtomicReferenceFieldUpdater atomicReferenceFieldUpdater = RESULT;
+                coroutine_suspended2 = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+                if (AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0.m(atomicReferenceFieldUpdater, this, coroutine_suspended2, CoroutineSingletons.RESUMED)) {
+                    this.delegate.resumeWith(obj);
+                    return;
+                }
+            } else if (AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0.m(RESULT, this, coroutineSingletons, obj)) {
+                return;
+            }
+        }
+    }
+
+    public final Object getOrThrow() {
+        Object coroutine_suspended;
+        Object coroutine_suspended2;
+        Object coroutine_suspended3;
+        Object obj = this.result;
+        CoroutineSingletons coroutineSingletons = CoroutineSingletons.UNDECIDED;
+        if (obj == coroutineSingletons) {
+            AtomicReferenceFieldUpdater atomicReferenceFieldUpdater = RESULT;
+            coroutine_suspended2 = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+            if (AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0.m(atomicReferenceFieldUpdater, this, coroutineSingletons, coroutine_suspended2)) {
+                coroutine_suspended3 = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+                return coroutine_suspended3;
+            }
+            obj = this.result;
+        }
+        if (obj == CoroutineSingletons.RESUMED) {
+            coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+            return coroutine_suspended;
+        }
+        if (obj instanceof Result.Failure) {
+            throw ((Result.Failure) obj).exception;
+        }
+        return obj;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.CoroutineStackFrame
+    public CoroutineStackFrame getCallerFrame() {
+        Continuation continuation = this.delegate;
+        if (continuation instanceof CoroutineStackFrame) {
+            return (CoroutineStackFrame) continuation;
+        }
+        return null;
+    }
+
+    public String toString() {
+        return "SafeContinuation for " + this.delegate;
+    }
+}

decompiled/sources/kotlin/coroutines/intrinsics/CoroutineSingletons.java

@@ -0,0 +1,40 @@
+package kotlin.coroutines.intrinsics;
+
+import kotlin.enums.EnumEntries;
+import kotlin.enums.EnumEntriesKt;
+
+/* 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: classes5.dex */
+public final class CoroutineSingletons {
+    private static final /* synthetic */ EnumEntries $ENTRIES;
+    private static final /* synthetic */ CoroutineSingletons[] $VALUES;
+    public static final CoroutineSingletons COROUTINE_SUSPENDED = new CoroutineSingletons("COROUTINE_SUSPENDED", 0);
+    public static final CoroutineSingletons UNDECIDED = new CoroutineSingletons("UNDECIDED", 1);
+    public static final CoroutineSingletons RESUMED = new CoroutineSingletons("RESUMED", 2);
+
+    private static final /* synthetic */ CoroutineSingletons[] $values() {
+        return new CoroutineSingletons[]{COROUTINE_SUSPENDED, UNDECIDED, RESUMED};
+    }
+
+    public static EnumEntries getEntries() {
+        return $ENTRIES;
+    }
+
+    public static CoroutineSingletons valueOf(String str) {
+        return (CoroutineSingletons) Enum.valueOf(CoroutineSingletons.class, str);
+    }
+
+    public static CoroutineSingletons[] values() {
+        return (CoroutineSingletons[]) $VALUES.clone();
+    }
+
+    private CoroutineSingletons(String str, int i) {
+    }
+
+    static {
+        CoroutineSingletons[] $values = $values();
+        $VALUES = $values;
+        $ENTRIES = EnumEntriesKt.enumEntries($values);
+    }
+}

decompiled/sources/kotlin/coroutines/intrinsics/IntrinsicsKt.java

@@ -0,0 +1,5 @@
+package kotlin.coroutines.intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class IntrinsicsKt extends IntrinsicsKt__IntrinsicsKt {
+}

decompiled/sources/kotlin/coroutines/intrinsics/IntrinsicsKt__IntrinsicsJvmKt.java

@@ -0,0 +1,166 @@
+package kotlin.coroutines.intrinsics;
+
+import kotlin.ResultKt;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.coroutines.EmptyCoroutineContext;
+import kotlin.coroutines.jvm.internal.BaseContinuationImpl;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.coroutines.jvm.internal.DebugProbesKt;
+import kotlin.coroutines.jvm.internal.RestrictedContinuationImpl;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.TypeIntrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class IntrinsicsKt__IntrinsicsJvmKt {
+    /* JADX WARN: Multi-variable type inference failed */
+    public static Continuation createCoroutineUnintercepted(final Function1 function1, Continuation completion) {
+        Intrinsics.checkNotNullParameter(function1, "<this>");
+        Intrinsics.checkNotNullParameter(completion, "completion");
+        final Continuation probeCoroutineCreated = DebugProbesKt.probeCoroutineCreated(completion);
+        if (function1 instanceof BaseContinuationImpl) {
+            return ((BaseContinuationImpl) function1).create(probeCoroutineCreated);
+        }
+        final CoroutineContext context = probeCoroutineCreated.getContext();
+        if (context == EmptyCoroutineContext.INSTANCE) {
+            return new RestrictedContinuationImpl(probeCoroutineCreated, function1) { // from class: kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt$createCoroutineUnintercepted$$inlined$createCoroutineFromSuspendFunction$IntrinsicsKt__IntrinsicsJvmKt$1
+                public final /* synthetic */ Function1 $this_createCoroutineUnintercepted$inlined;
+                public int label;
+
+                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+                {
+                    super(probeCoroutineCreated);
+                    this.$this_createCoroutineUnintercepted$inlined = function1;
+                    Intrinsics.checkNotNull(probeCoroutineCreated, "null cannot be cast to non-null type kotlin.coroutines.Continuation<kotlin.Any?>");
+                }
+
+                @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+                public Object invokeSuspend(Object obj) {
+                    int i = this.label;
+                    if (i == 0) {
+                        this.label = 1;
+                        ResultKt.throwOnFailure(obj);
+                        Intrinsics.checkNotNull(this.$this_createCoroutineUnintercepted$inlined, "null cannot be cast to non-null type kotlin.Function1<kotlin.coroutines.Continuation<T of kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt.createCoroutineUnintercepted$lambda$0>, kotlin.Any?>");
+                        return ((Function1) TypeIntrinsics.beforeCheckcastToFunctionOfArity(this.$this_createCoroutineUnintercepted$inlined, 1)).invoke(this);
+                    }
+                    if (i == 1) {
+                        this.label = 2;
+                        ResultKt.throwOnFailure(obj);
+                        return obj;
+                    }
+                    throw new IllegalStateException("This coroutine had already completed".toString());
+                }
+            };
+        }
+        return new ContinuationImpl(probeCoroutineCreated, context, function1) { // from class: kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt$createCoroutineUnintercepted$$inlined$createCoroutineFromSuspendFunction$IntrinsicsKt__IntrinsicsJvmKt$2
+            public final /* synthetic */ Function1 $this_createCoroutineUnintercepted$inlined;
+            public int label;
+
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(probeCoroutineCreated, context);
+                this.$this_createCoroutineUnintercepted$inlined = function1;
+                Intrinsics.checkNotNull(probeCoroutineCreated, "null cannot be cast to non-null type kotlin.coroutines.Continuation<kotlin.Any?>");
+            }
+
+            @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+            public Object invokeSuspend(Object obj) {
+                int i = this.label;
+                if (i == 0) {
+                    this.label = 1;
+                    ResultKt.throwOnFailure(obj);
+                    Intrinsics.checkNotNull(this.$this_createCoroutineUnintercepted$inlined, "null cannot be cast to non-null type kotlin.Function1<kotlin.coroutines.Continuation<T of kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt.createCoroutineUnintercepted$lambda$0>, kotlin.Any?>");
+                    return ((Function1) TypeIntrinsics.beforeCheckcastToFunctionOfArity(this.$this_createCoroutineUnintercepted$inlined, 1)).invoke(this);
+                }
+                if (i == 1) {
+                    this.label = 2;
+                    ResultKt.throwOnFailure(obj);
+                    return obj;
+                }
+                throw new IllegalStateException("This coroutine had already completed".toString());
+            }
+        };
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public static Continuation createCoroutineUnintercepted(final Function2 function2, final Object obj, Continuation completion) {
+        Intrinsics.checkNotNullParameter(function2, "<this>");
+        Intrinsics.checkNotNullParameter(completion, "completion");
+        final Continuation probeCoroutineCreated = DebugProbesKt.probeCoroutineCreated(completion);
+        if (function2 instanceof BaseContinuationImpl) {
+            return ((BaseContinuationImpl) function2).create(obj, probeCoroutineCreated);
+        }
+        final CoroutineContext context = probeCoroutineCreated.getContext();
+        if (context == EmptyCoroutineContext.INSTANCE) {
+            return new RestrictedContinuationImpl(probeCoroutineCreated, function2, obj) { // from class: kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt$createCoroutineUnintercepted$$inlined$createCoroutineFromSuspendFunction$IntrinsicsKt__IntrinsicsJvmKt$3
+                public final /* synthetic */ Object $receiver$inlined;
+                public final /* synthetic */ Function2 $this_createCoroutineUnintercepted$inlined;
+                public int label;
+
+                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+                {
+                    super(probeCoroutineCreated);
+                    this.$this_createCoroutineUnintercepted$inlined = function2;
+                    this.$receiver$inlined = obj;
+                    Intrinsics.checkNotNull(probeCoroutineCreated, "null cannot be cast to non-null type kotlin.coroutines.Continuation<kotlin.Any?>");
+                }
+
+                @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+                public Object invokeSuspend(Object obj2) {
+                    int i = this.label;
+                    if (i == 0) {
+                        this.label = 1;
+                        ResultKt.throwOnFailure(obj2);
+                        Intrinsics.checkNotNull(this.$this_createCoroutineUnintercepted$inlined, "null cannot be cast to non-null type kotlin.Function2<R of kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt.createCoroutineUnintercepted$lambda$1, kotlin.coroutines.Continuation<T of kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt.createCoroutineUnintercepted$lambda$1>, kotlin.Any?>");
+                        return ((Function2) TypeIntrinsics.beforeCheckcastToFunctionOfArity(this.$this_createCoroutineUnintercepted$inlined, 2)).invoke(this.$receiver$inlined, this);
+                    }
+                    if (i == 1) {
+                        this.label = 2;
+                        ResultKt.throwOnFailure(obj2);
+                        return obj2;
+                    }
+                    throw new IllegalStateException("This coroutine had already completed".toString());
+                }
+            };
+        }
+        return new ContinuationImpl(probeCoroutineCreated, context, function2, obj) { // from class: kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt$createCoroutineUnintercepted$$inlined$createCoroutineFromSuspendFunction$IntrinsicsKt__IntrinsicsJvmKt$4
+            public final /* synthetic */ Object $receiver$inlined;
+            public final /* synthetic */ Function2 $this_createCoroutineUnintercepted$inlined;
+            public int label;
+
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(probeCoroutineCreated, context);
+                this.$this_createCoroutineUnintercepted$inlined = function2;
+                this.$receiver$inlined = obj;
+                Intrinsics.checkNotNull(probeCoroutineCreated, "null cannot be cast to non-null type kotlin.coroutines.Continuation<kotlin.Any?>");
+            }
+
+            @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+            public Object invokeSuspend(Object obj2) {
+                int i = this.label;
+                if (i == 0) {
+                    this.label = 1;
+                    ResultKt.throwOnFailure(obj2);
+                    Intrinsics.checkNotNull(this.$this_createCoroutineUnintercepted$inlined, "null cannot be cast to non-null type kotlin.Function2<R of kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt.createCoroutineUnintercepted$lambda$1, kotlin.coroutines.Continuation<T of kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt.createCoroutineUnintercepted$lambda$1>, kotlin.Any?>");
+                    return ((Function2) TypeIntrinsics.beforeCheckcastToFunctionOfArity(this.$this_createCoroutineUnintercepted$inlined, 2)).invoke(this.$receiver$inlined, this);
+                }
+                if (i == 1) {
+                    this.label = 2;
+                    ResultKt.throwOnFailure(obj2);
+                    return obj2;
+                }
+                throw new IllegalStateException("This coroutine had already completed".toString());
+            }
+        };
+    }
+
+    public static Continuation intercepted(Continuation continuation) {
+        Continuation intercepted;
+        Intrinsics.checkNotNullParameter(continuation, "<this>");
+        ContinuationImpl continuationImpl = continuation instanceof ContinuationImpl ? (ContinuationImpl) continuation : null;
+        return (continuationImpl == null || (intercepted = continuationImpl.intercepted()) == null) ? continuation : intercepted;
+    }
+}

decompiled/sources/kotlin/coroutines/intrinsics/IntrinsicsKt__IntrinsicsKt.java

@@ -0,0 +1,8 @@
+package kotlin.coroutines.intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class IntrinsicsKt__IntrinsicsKt extends IntrinsicsKt__IntrinsicsJvmKt {
+    public static Object getCOROUTINE_SUSPENDED() {
+        return CoroutineSingletons.COROUTINE_SUSPENDED;
+    }
+}

decompiled/sources/kotlin/coroutines/jvm/internal/BaseContinuationImpl.java

@@ -0,0 +1,90 @@
+package kotlin.coroutines.jvm.internal;
+
+import java.io.Serializable;
+import kotlin.Result;
+import kotlin.ResultKt;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class BaseContinuationImpl implements Continuation, CoroutineStackFrame, Serializable {
+    private final Continuation completion;
+
+    public final Continuation getCompletion() {
+        return this.completion;
+    }
+
+    public abstract Object invokeSuspend(Object obj);
+
+    public void releaseIntercepted() {
+    }
+
+    public BaseContinuationImpl(Continuation continuation) {
+        this.completion = continuation;
+    }
+
+    @Override // kotlin.coroutines.Continuation
+    public final void resumeWith(Object obj) {
+        Object invokeSuspend;
+        Object coroutine_suspended;
+        Continuation continuation = this;
+        while (true) {
+            DebugProbesKt.probeCoroutineResumed(continuation);
+            BaseContinuationImpl baseContinuationImpl = (BaseContinuationImpl) continuation;
+            Continuation continuation2 = baseContinuationImpl.completion;
+            Intrinsics.checkNotNull(continuation2);
+            try {
+                invokeSuspend = baseContinuationImpl.invokeSuspend(obj);
+                coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+            } catch (Throwable th) {
+                Result.Companion companion = Result.Companion;
+                obj = Result.m4060constructorimpl(ResultKt.createFailure(th));
+            }
+            if (invokeSuspend == coroutine_suspended) {
+                return;
+            }
+            obj = Result.m4060constructorimpl(invokeSuspend);
+            baseContinuationImpl.releaseIntercepted();
+            if (!(continuation2 instanceof BaseContinuationImpl)) {
+                continuation2.resumeWith(obj);
+                return;
+            }
+            continuation = continuation2;
+        }
+    }
+
+    public Continuation create(Continuation completion) {
+        Intrinsics.checkNotNullParameter(completion, "completion");
+        throw new UnsupportedOperationException("create(Continuation) has not been overridden");
+    }
+
+    public Continuation create(Object obj, Continuation completion) {
+        Intrinsics.checkNotNullParameter(completion, "completion");
+        throw new UnsupportedOperationException("create(Any?;Continuation) has not been overridden");
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Continuation at ");
+        Object stackTraceElement = getStackTraceElement();
+        if (stackTraceElement == null) {
+            stackTraceElement = getClass().getName();
+        }
+        sb.append(stackTraceElement);
+        return sb.toString();
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.CoroutineStackFrame
+    public CoroutineStackFrame getCallerFrame() {
+        Continuation continuation = this.completion;
+        if (continuation instanceof CoroutineStackFrame) {
+            return (CoroutineStackFrame) continuation;
+        }
+        return null;
+    }
+
+    public StackTraceElement getStackTraceElement() {
+        return DebugMetadataKt.getStackTraceElement(this);
+    }
+}

decompiled/sources/kotlin/coroutines/jvm/internal/Boxing.java

@@ -0,0 +1,20 @@
+package kotlin.coroutines.jvm.internal;
+
+/* loaded from: classes5.dex */
+public abstract class Boxing {
+    public static final Boolean boxBoolean(boolean z) {
+        return Boolean.valueOf(z);
+    }
+
+    public static final Integer boxInt(int i) {
+        return new Integer(i);
+    }
+
+    public static final Long boxLong(long j) {
+        return new Long(j);
+    }
+
+    public static final Double boxDouble(double d) {
+        return new Double(d);
+    }
+}

decompiled/sources/kotlin/coroutines/jvm/internal/CompletedContinuation.java

@@ -0,0 +1,23 @@
+package kotlin.coroutines.jvm.internal;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+
+/* loaded from: classes5.dex */
+public final class CompletedContinuation implements Continuation {
+    public static final CompletedContinuation INSTANCE = new CompletedContinuation();
+
+    public String toString() {
+        return "This continuation is already complete";
+    }
+
+    @Override // kotlin.coroutines.Continuation
+    public CoroutineContext getContext() {
+        throw new IllegalStateException("This continuation is already complete".toString());
+    }
+
+    @Override // kotlin.coroutines.Continuation
+    public void resumeWith(Object obj) {
+        throw new IllegalStateException("This continuation is already complete".toString());
+    }
+}

decompiled/sources/kotlin/coroutines/jvm/internal/ContinuationImpl.java

@@ -0,0 +1,51 @@
+package kotlin.coroutines.jvm.internal;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.ContinuationInterceptor;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class ContinuationImpl extends BaseContinuationImpl {
+    private final CoroutineContext _context;
+    private transient Continuation intercepted;
+
+    public ContinuationImpl(Continuation continuation, CoroutineContext coroutineContext) {
+        super(continuation);
+        this._context = coroutineContext;
+    }
+
+    public ContinuationImpl(Continuation continuation) {
+        this(continuation, continuation != null ? continuation.getContext() : null);
+    }
+
+    @Override // kotlin.coroutines.Continuation
+    public CoroutineContext getContext() {
+        CoroutineContext coroutineContext = this._context;
+        Intrinsics.checkNotNull(coroutineContext);
+        return coroutineContext;
+    }
+
+    public final Continuation intercepted() {
+        Continuation continuation = this.intercepted;
+        if (continuation == null) {
+            ContinuationInterceptor continuationInterceptor = (ContinuationInterceptor) getContext().get(ContinuationInterceptor.Key);
+            if (continuationInterceptor == null || (continuation = continuationInterceptor.interceptContinuation(this)) == null) {
+                continuation = this;
+            }
+            this.intercepted = continuation;
+        }
+        return continuation;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public void releaseIntercepted() {
+        Continuation continuation = this.intercepted;
+        if (continuation != null && continuation != this) {
+            CoroutineContext.Element element = getContext().get(ContinuationInterceptor.Key);
+            Intrinsics.checkNotNull(element);
+            ((ContinuationInterceptor) element).releaseInterceptedContinuation(continuation);
+        }
+        this.intercepted = CompletedContinuation.INSTANCE;
+    }
+}

decompiled/sources/kotlin/coroutines/jvm/internal/CoroutineStackFrame.java

@@ -0,0 +1,6 @@
+package kotlin.coroutines.jvm.internal;
+
+/* loaded from: classes5.dex */
+public interface CoroutineStackFrame {
+    CoroutineStackFrame getCallerFrame();
+}

decompiled/sources/kotlin/coroutines/jvm/internal/DebugMetadata.java

@@ -0,0 +1,21 @@
+package kotlin.coroutines.jvm.internal;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* JADX WARN: Method from annotation default annotation not found: i */
+/* JADX WARN: Method from annotation default annotation not found: n */
+/* JADX WARN: Method from annotation default annotation not found: s */
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes5.dex */
+public @interface DebugMetadata {
+    String c() default "";
+
+    String f() default "";
+
+    int[] l() default {};
+
+    String m() default "";
+
+    int v() default 1;
+}

decompiled/sources/kotlin/coroutines/jvm/internal/DebugMetadataKt.java

@@ -0,0 +1,49 @@
+package kotlin.coroutines.jvm.internal;
+
+import java.lang.reflect.Field;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class DebugMetadataKt {
+    public static final StackTraceElement getStackTraceElement(BaseContinuationImpl baseContinuationImpl) {
+        String str;
+        Intrinsics.checkNotNullParameter(baseContinuationImpl, "<this>");
+        DebugMetadata debugMetadataAnnotation = getDebugMetadataAnnotation(baseContinuationImpl);
+        if (debugMetadataAnnotation == null) {
+            return null;
+        }
+        checkDebugMetadataVersion(1, debugMetadataAnnotation.v());
+        int label = getLabel(baseContinuationImpl);
+        int i = label < 0 ? -1 : debugMetadataAnnotation.l()[label];
+        String moduleName = ModuleNameRetriever.INSTANCE.getModuleName(baseContinuationImpl);
+        if (moduleName == null) {
+            str = debugMetadataAnnotation.c();
+        } else {
+            str = moduleName + '/' + debugMetadataAnnotation.c();
+        }
+        return new StackTraceElement(str, debugMetadataAnnotation.m(), debugMetadataAnnotation.f(), i);
+    }
+
+    public static final DebugMetadata getDebugMetadataAnnotation(BaseContinuationImpl baseContinuationImpl) {
+        return (DebugMetadata) baseContinuationImpl.getClass().getAnnotation(DebugMetadata.class);
+    }
+
+    public static final int getLabel(BaseContinuationImpl baseContinuationImpl) {
+        try {
+            Field declaredField = baseContinuationImpl.getClass().getDeclaredField("label");
+            declaredField.setAccessible(true);
+            Object obj = declaredField.get(baseContinuationImpl);
+            Integer num = obj instanceof Integer ? (Integer) obj : null;
+            return (num != null ? num.intValue() : 0) - 1;
+        } catch (Exception unused) {
+            return -1;
+        }
+    }
+
+    public static final void checkDebugMetadataVersion(int i, int i2) {
+        if (i2 <= i) {
+            return;
+        }
+        throw new IllegalStateException(("Debug metadata version mismatch. Expected: " + i + ", got " + i2 + ". Please update the Kotlin standard library.").toString());
+    }
+}

decompiled/sources/kotlin/coroutines/jvm/internal/DebugProbesKt.java

@@ -0,0 +1,33 @@
+package kotlin.coroutines.jvm.internal;
+
+import com.fyber.inneractive.sdk.bidder.TokenParametersOuterClass$TokenParameters;
+import com.google.android.gms.ads.RequestConfiguration;
+import kotlin.Metadata;
+import kotlin.coroutines.Continuation;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.debug.internal.DebugProbesImpl;
+import org.jetbrains.annotations.NotNull;
+
+/* JADX WARN: Classes with same name are omitted:
+  classes5.dex
+ */
+/* compiled from: DebugProbes.kt */
+@Metadata(mv = {1, 8, 0}, k = 2, xi = TokenParametersOuterClass$TokenParameters.LOWPOWERMODE_FIELD_NUMBER, d1 = {"<EFBFBD><EFBFBD>\u0012\n<EFBFBD><EFBFBD>\n\u0002\u0018\u0002\n\u0002\b\u0003\n\u0002\u0010\u0002\n\u0002\b\u0003\u001a\"\u0010<EFBFBD><EFBFBD>\u001a\b\u0012\u0004\u0012\u0002H\u00020\u0001\"\u0004\b<EFBFBD><EFBFBD>\u0010\u00022\f\u0010\u0003\u001a\b\u0012\u0004\u0012\u0002H\u00020\u0001H<EFBFBD><EFBFBD>\u001a\u0014\u0010\u0004\u001a\u00020\u00052\n\u0010\u0006\u001a\u0006\u0012\u0002\b\u00030\u0001H<EFBFBD><EFBFBD>\u001a\u0014\u0010\u0007\u001a\u00020\u00052\n\u0010\u0006\u001a\u0006\u0012\u0002\b\u00030\u0001H<EFBFBD><EFBFBD>¨\u0006\b"}, d2 = {"probeCoroutineCreated", "Lkotlin/coroutines/Continuation;", RequestConfiguration.MAX_AD_CONTENT_RATING_T, "completion", "probeCoroutineResumed", "", "frame", "probeCoroutineSuspended", "kotlinx-coroutines-integration-testing_debugAgentTest"})
+/* loaded from: realracing3.apk:DebugProbesKt.bin */
+public final class DebugProbesKt {
+    @NotNull
+    public static final <T> Continuation<T> probeCoroutineCreated(@NotNull Continuation<? super T> completion) {
+        Intrinsics.checkNotNullParameter(completion, "completion");
+        return DebugProbesImpl.INSTANCE.probeCoroutineCreated$kotlinx_coroutines_core(completion);
+    }
+
+    public static final void probeCoroutineResumed(@NotNull Continuation<?> frame) {
+        Intrinsics.checkNotNullParameter(frame, "frame");
+        DebugProbesImpl.INSTANCE.probeCoroutineResumed$kotlinx_coroutines_core(frame);
+    }
+
+    public static final void probeCoroutineSuspended(@NotNull Continuation<?> frame) {
+        Intrinsics.checkNotNullParameter(frame, "frame");
+        DebugProbesImpl.INSTANCE.probeCoroutineSuspended$kotlinx_coroutines_core(frame);
+    }
+}

decompiled/sources/kotlin/coroutines/jvm/internal/ModuleNameRetriever.java

@@ -0,0 +1,62 @@
+package kotlin.coroutines.jvm.internal;
+
+import java.lang.reflect.Method;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class ModuleNameRetriever {
+    public static Cache cache;
+    public static final ModuleNameRetriever INSTANCE = new ModuleNameRetriever();
+    public static final Cache notOnJava9 = new Cache(null, null, null);
+
+    public static final class Cache {
+        public final Method getDescriptorMethod;
+        public final Method getModuleMethod;
+        public final Method nameMethod;
+
+        public Cache(Method method, Method method2, Method method3) {
+            this.getModuleMethod = method;
+            this.getDescriptorMethod = method2;
+            this.nameMethod = method3;
+        }
+    }
+
+    public final String getModuleName(BaseContinuationImpl continuation) {
+        Intrinsics.checkNotNullParameter(continuation, "continuation");
+        Cache cache2 = cache;
+        if (cache2 == null) {
+            cache2 = buildCache(continuation);
+        }
+        if (cache2 == notOnJava9) {
+            return null;
+        }
+        Method method = cache2.getModuleMethod;
+        Object invoke = method != null ? method.invoke(continuation.getClass(), new Object[0]) : null;
+        if (invoke == null) {
+            return null;
+        }
+        Method method2 = cache2.getDescriptorMethod;
+        Object invoke2 = method2 != null ? method2.invoke(invoke, new Object[0]) : null;
+        if (invoke2 == null) {
+            return null;
+        }
+        Method method3 = cache2.nameMethod;
+        Object invoke3 = method3 != null ? method3.invoke(invoke2, new Object[0]) : null;
+        if (invoke3 instanceof String) {
+            return (String) invoke3;
+        }
+        return null;
+    }
+
+    public final Cache buildCache(BaseContinuationImpl baseContinuationImpl) {
+        try {
+            Cache cache2 = new Cache(Class.class.getDeclaredMethod("getModule", new Class[0]), baseContinuationImpl.getClass().getClassLoader().loadClass("java.lang.Module").getDeclaredMethod("getDescriptor", new Class[0]), baseContinuationImpl.getClass().getClassLoader().loadClass("java.lang.module.ModuleDescriptor").getDeclaredMethod("name", new Class[0]));
+            cache = cache2;
+            return cache2;
+        } catch (Exception unused) {
+            Cache cache3 = notOnJava9;
+            cache = cache3;
+            return cache3;
+        }
+    }
+}

decompiled/sources/kotlin/coroutines/jvm/internal/RestrictedContinuationImpl.java

@@ -0,0 +1,20 @@
+package kotlin.coroutines.jvm.internal;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.coroutines.EmptyCoroutineContext;
+
+/* loaded from: classes5.dex */
+public abstract class RestrictedContinuationImpl extends BaseContinuationImpl {
+    public RestrictedContinuationImpl(Continuation continuation) {
+        super(continuation);
+        if (continuation != null && continuation.getContext() != EmptyCoroutineContext.INSTANCE) {
+            throw new IllegalArgumentException("Coroutines with restricted suspension must have EmptyCoroutineContext".toString());
+        }
+    }
+
+    @Override // kotlin.coroutines.Continuation
+    public CoroutineContext getContext() {
+        return EmptyCoroutineContext.INSTANCE;
+    }
+}

decompiled/sources/kotlin/coroutines/jvm/internal/RestrictedSuspendLambda.java

@@ -0,0 +1,31 @@
+package kotlin.coroutines.jvm.internal;
+
+import kotlin.coroutines.Continuation;
+import kotlin.jvm.internal.FunctionBase;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Reflection;
+
+/* loaded from: classes5.dex */
+public abstract class RestrictedSuspendLambda extends RestrictedContinuationImpl implements FunctionBase {
+    private final int arity;
+
+    @Override // kotlin.jvm.internal.FunctionBase
+    public int getArity() {
+        return this.arity;
+    }
+
+    public RestrictedSuspendLambda(int i, Continuation continuation) {
+        super(continuation);
+        this.arity = i;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public String toString() {
+        if (getCompletion() == null) {
+            String renderLambdaToString = Reflection.renderLambdaToString(this);
+            Intrinsics.checkNotNullExpressionValue(renderLambdaToString, "renderLambdaToString(...)");
+            return renderLambdaToString;
+        }
+        return super.toString();
+    }
+}

decompiled/sources/kotlin/coroutines/jvm/internal/SuspendLambda.java

@@ -0,0 +1,31 @@
+package kotlin.coroutines.jvm.internal;
+
+import kotlin.coroutines.Continuation;
+import kotlin.jvm.internal.FunctionBase;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Reflection;
+
+/* loaded from: classes5.dex */
+public abstract class SuspendLambda extends ContinuationImpl implements FunctionBase {
+    private final int arity;
+
+    @Override // kotlin.jvm.internal.FunctionBase
+    public int getArity() {
+        return this.arity;
+    }
+
+    public SuspendLambda(int i, Continuation continuation) {
+        super(continuation);
+        this.arity = i;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public String toString() {
+        if (getCompletion() == null) {
+            String renderLambdaToString = Reflection.renderLambdaToString(this);
+            Intrinsics.checkNotNullExpressionValue(renderLambdaToString, "renderLambdaToString(...)");
+            return renderLambdaToString;
+        }
+        return super.toString();
+    }
+}