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