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/kotlinx/coroutines/flow/internal/AbortFlowException.java

@@ -0,0 +1,20 @@
+package kotlinx.coroutines.flow.internal;
+
+import java.util.concurrent.CancellationException;
+import kotlinx.coroutines.flow.FlowCollector;
+
+/* loaded from: classes5.dex */
+public final class AbortFlowException extends CancellationException {
+    public final transient FlowCollector owner;
+
+    public AbortFlowException(FlowCollector flowCollector) {
+        super("Flow was aborted, no more elements needed");
+        this.owner = flowCollector;
+    }
+
+    @Override // java.lang.Throwable
+    public Throwable fillInStackTrace() {
+        setStackTrace(new StackTraceElement[0]);
+        return this;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/AbstractSharedFlow.java

@@ -0,0 +1,110 @@
+package kotlinx.coroutines.flow.internal;
+
+import java.util.Arrays;
+import kotlin.Result;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.flow.StateFlow;
+
+/* loaded from: classes5.dex */
+public abstract class AbstractSharedFlow {
+    public SubscriptionCountStateFlow _subscriptionCount;
+    public int nCollectors;
+    public int nextIndex;
+    public AbstractSharedFlowSlot[] slots;
+
+    public abstract AbstractSharedFlowSlot createSlot();
+
+    public abstract AbstractSharedFlowSlot[] createSlotArray(int i);
+
+    public final int getNCollectors() {
+        return this.nCollectors;
+    }
+
+    public final AbstractSharedFlowSlot[] getSlots() {
+        return this.slots;
+    }
+
+    public final AbstractSharedFlowSlot allocateSlot() {
+        AbstractSharedFlowSlot abstractSharedFlowSlot;
+        SubscriptionCountStateFlow subscriptionCountStateFlow;
+        synchronized (this) {
+            try {
+                AbstractSharedFlowSlot[] abstractSharedFlowSlotArr = this.slots;
+                if (abstractSharedFlowSlotArr == null) {
+                    abstractSharedFlowSlotArr = createSlotArray(2);
+                    this.slots = abstractSharedFlowSlotArr;
+                } else if (this.nCollectors >= abstractSharedFlowSlotArr.length) {
+                    Object[] copyOf = Arrays.copyOf(abstractSharedFlowSlotArr, abstractSharedFlowSlotArr.length * 2);
+                    Intrinsics.checkNotNullExpressionValue(copyOf, "copyOf(this, newSize)");
+                    this.slots = (AbstractSharedFlowSlot[]) copyOf;
+                    abstractSharedFlowSlotArr = (AbstractSharedFlowSlot[]) copyOf;
+                }
+                int i = this.nextIndex;
+                do {
+                    abstractSharedFlowSlot = abstractSharedFlowSlotArr[i];
+                    if (abstractSharedFlowSlot == null) {
+                        abstractSharedFlowSlot = createSlot();
+                        abstractSharedFlowSlotArr[i] = abstractSharedFlowSlot;
+                    }
+                    i++;
+                    if (i >= abstractSharedFlowSlotArr.length) {
+                        i = 0;
+                    }
+                    Intrinsics.checkNotNull(abstractSharedFlowSlot, "null cannot be cast to non-null type kotlinx.coroutines.flow.internal.AbstractSharedFlowSlot<kotlin.Any>");
+                } while (!abstractSharedFlowSlot.allocateLocked(this));
+                this.nextIndex = i;
+                this.nCollectors++;
+                subscriptionCountStateFlow = this._subscriptionCount;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        if (subscriptionCountStateFlow != null) {
+            subscriptionCountStateFlow.increment(1);
+        }
+        return abstractSharedFlowSlot;
+    }
+
+    public final void freeSlot(AbstractSharedFlowSlot abstractSharedFlowSlot) {
+        SubscriptionCountStateFlow subscriptionCountStateFlow;
+        int i;
+        Continuation[] freeLocked;
+        synchronized (this) {
+            try {
+                int i2 = this.nCollectors - 1;
+                this.nCollectors = i2;
+                subscriptionCountStateFlow = this._subscriptionCount;
+                if (i2 == 0) {
+                    this.nextIndex = 0;
+                }
+                Intrinsics.checkNotNull(abstractSharedFlowSlot, "null cannot be cast to non-null type kotlinx.coroutines.flow.internal.AbstractSharedFlowSlot<kotlin.Any>");
+                freeLocked = abstractSharedFlowSlot.freeLocked(this);
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        for (Continuation continuation : freeLocked) {
+            if (continuation != null) {
+                Result.Companion companion = Result.Companion;
+                continuation.resumeWith(Result.m4060constructorimpl(Unit.INSTANCE));
+            }
+        }
+        if (subscriptionCountStateFlow != null) {
+            subscriptionCountStateFlow.increment(-1);
+        }
+    }
+
+    public final StateFlow getSubscriptionCount() {
+        SubscriptionCountStateFlow subscriptionCountStateFlow;
+        synchronized (this) {
+            subscriptionCountStateFlow = this._subscriptionCount;
+            if (subscriptionCountStateFlow == null) {
+                subscriptionCountStateFlow = new SubscriptionCountStateFlow(this.nCollectors);
+                this._subscriptionCount = subscriptionCountStateFlow;
+            }
+        }
+        return subscriptionCountStateFlow;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/AbstractSharedFlowKt.java

@@ -0,0 +1,8 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.coroutines.Continuation;
+
+/* loaded from: classes5.dex */
+public abstract class AbstractSharedFlowKt {
+    public static final Continuation[] EMPTY_RESUMES = new Continuation[0];
+}

decompiled/sources/kotlinx/coroutines/flow/internal/AbstractSharedFlowSlot.java

@@ -0,0 +1,10 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.coroutines.Continuation;
+
+/* loaded from: classes5.dex */
+public abstract class AbstractSharedFlowSlot {
+    public abstract boolean allocateLocked(Object obj);
+
+    public abstract Continuation[] freeLocked(Object obj);
+}

decompiled/sources/kotlinx/coroutines/flow/internal/ChannelFlow$collect$2.java

@@ -0,0 +1,62 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+import kotlinx.coroutines.channels.ReceiveChannel;
+import kotlinx.coroutines.flow.FlowCollector;
+import kotlinx.coroutines.flow.FlowKt;
+
+/* loaded from: classes5.dex */
+public final class ChannelFlow$collect$2 extends SuspendLambda implements Function2 {
+    public final /* synthetic */ FlowCollector $collector;
+    public /* synthetic */ Object L$0;
+    public int label;
+    public final /* synthetic */ ChannelFlow this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public ChannelFlow$collect$2(FlowCollector flowCollector, ChannelFlow channelFlow, Continuation continuation) {
+        super(2, continuation);
+        this.$collector = flowCollector;
+        this.this$0 = channelFlow;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        ChannelFlow$collect$2 channelFlow$collect$2 = new ChannelFlow$collect$2(this.$collector, this.this$0, continuation);
+        channelFlow$collect$2.L$0 = obj;
+        return channelFlow$collect$2;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(CoroutineScope coroutineScope, Continuation continuation) {
+        return ((ChannelFlow$collect$2) create(coroutineScope, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended;
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.label;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            CoroutineScope coroutineScope = (CoroutineScope) this.L$0;
+            FlowCollector flowCollector = this.$collector;
+            ReceiveChannel produceImpl = this.this$0.produceImpl(coroutineScope);
+            this.label = 1;
+            if (FlowKt.emitAll(flowCollector, produceImpl, 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;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/ChannelFlow$collectToFun$1.java

@@ -0,0 +1,56 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.channels.ProducerScope;
+
+/* loaded from: classes5.dex */
+public final class ChannelFlow$collectToFun$1 extends SuspendLambda implements Function2 {
+    public /* synthetic */ Object L$0;
+    public int label;
+    public final /* synthetic */ ChannelFlow this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public ChannelFlow$collectToFun$1(ChannelFlow channelFlow, Continuation continuation) {
+        super(2, continuation);
+        this.this$0 = channelFlow;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        ChannelFlow$collectToFun$1 channelFlow$collectToFun$1 = new ChannelFlow$collectToFun$1(this.this$0, continuation);
+        channelFlow$collectToFun$1.L$0 = obj;
+        return channelFlow$collectToFun$1;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(ProducerScope producerScope, Continuation continuation) {
+        return ((ChannelFlow$collectToFun$1) create(producerScope, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended;
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.label;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            ProducerScope producerScope = (ProducerScope) this.L$0;
+            ChannelFlow channelFlow = this.this$0;
+            this.label = 1;
+            if (channelFlow.collectTo(producerScope, 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;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/ChannelFlow.java

@@ -0,0 +1,122 @@
+package kotlinx.coroutines.flow.internal;
+
+import java.util.ArrayList;
+import kotlin.Unit;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.coroutines.EmptyCoroutineContext;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.CoroutineScope;
+import kotlinx.coroutines.CoroutineScopeKt;
+import kotlinx.coroutines.CoroutineStart;
+import kotlinx.coroutines.DebugStringsKt;
+import kotlinx.coroutines.channels.BufferOverflow;
+import kotlinx.coroutines.channels.ProduceKt;
+import kotlinx.coroutines.channels.ProducerScope;
+import kotlinx.coroutines.channels.ReceiveChannel;
+import kotlinx.coroutines.flow.Flow;
+import kotlinx.coroutines.flow.FlowCollector;
+
+/* loaded from: classes5.dex */
+public abstract class ChannelFlow implements FusibleFlow {
+    public final int capacity;
+    public final CoroutineContext context;
+    public final BufferOverflow onBufferOverflow;
+
+    public String additionalToStringProps() {
+        return null;
+    }
+
+    @Override // kotlinx.coroutines.flow.Flow
+    public Object collect(FlowCollector flowCollector, Continuation continuation) {
+        return collect$suspendImpl(this, flowCollector, continuation);
+    }
+
+    public abstract Object collectTo(ProducerScope producerScope, Continuation continuation);
+
+    public abstract ChannelFlow create(CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow);
+
+    public Flow dropChannelOperators() {
+        return null;
+    }
+
+    public final int getProduceCapacity$kotlinx_coroutines_core() {
+        int i = this.capacity;
+        if (i == -3) {
+            return -2;
+        }
+        return i;
+    }
+
+    public ChannelFlow(CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow) {
+        this.context = coroutineContext;
+        this.capacity = i;
+        this.onBufferOverflow = bufferOverflow;
+    }
+
+    public final Function2 getCollectToFun$kotlinx_coroutines_core() {
+        return new ChannelFlow$collectToFun$1(this, null);
+    }
+
+    @Override // kotlinx.coroutines.flow.internal.FusibleFlow
+    public Flow fuse(CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow) {
+        CoroutineContext plus = coroutineContext.plus(this.context);
+        if (bufferOverflow == BufferOverflow.SUSPEND) {
+            int i2 = this.capacity;
+            if (i2 != -3) {
+                if (i != -3) {
+                    if (i2 != -2) {
+                        if (i != -2) {
+                            i += i2;
+                            if (i < 0) {
+                                i = Integer.MAX_VALUE;
+                            }
+                        }
+                    }
+                }
+                i = i2;
+            }
+            bufferOverflow = this.onBufferOverflow;
+        }
+        return (Intrinsics.areEqual(plus, this.context) && i == this.capacity && bufferOverflow == this.onBufferOverflow) ? this : create(plus, i, bufferOverflow);
+    }
+
+    public ReceiveChannel produceImpl(CoroutineScope coroutineScope) {
+        return ProduceKt.produce$default(coroutineScope, this.context, getProduceCapacity$kotlinx_coroutines_core(), this.onBufferOverflow, CoroutineStart.ATOMIC, null, getCollectToFun$kotlinx_coroutines_core(), 16, null);
+    }
+
+    public static /* synthetic */ Object collect$suspendImpl(ChannelFlow channelFlow, FlowCollector flowCollector, Continuation continuation) {
+        Object coroutine_suspended;
+        Object coroutineScope = CoroutineScopeKt.coroutineScope(new ChannelFlow$collect$2(flowCollector, channelFlow, null), continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return coroutineScope == coroutine_suspended ? coroutineScope : Unit.INSTANCE;
+    }
+
+    public String toString() {
+        String joinToString$default;
+        ArrayList arrayList = new ArrayList(4);
+        String additionalToStringProps = additionalToStringProps();
+        if (additionalToStringProps != null) {
+            arrayList.add(additionalToStringProps);
+        }
+        if (this.context != EmptyCoroutineContext.INSTANCE) {
+            arrayList.add("context=" + this.context);
+        }
+        if (this.capacity != -3) {
+            arrayList.add("capacity=" + this.capacity);
+        }
+        if (this.onBufferOverflow != BufferOverflow.SUSPEND) {
+            arrayList.add("onBufferOverflow=" + this.onBufferOverflow);
+        }
+        StringBuilder sb = new StringBuilder();
+        sb.append(DebugStringsKt.getClassSimpleName(this));
+        sb.append('[');
+        joinToString$default = CollectionsKt___CollectionsKt.joinToString$default(arrayList, ", ", null, null, 0, null, null, 62, null);
+        sb.append(joinToString$default);
+        sb.append(']');
+        return sb.toString();
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/ChannelFlowKt.java

@@ -0,0 +1,41 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.DebugProbesKt;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.TypeIntrinsics;
+import kotlinx.coroutines.flow.FlowCollector;
+import kotlinx.coroutines.internal.ThreadContextKt;
+
+/* loaded from: classes5.dex */
+public abstract class ChannelFlowKt {
+    public static final Object withContextUndispatched(CoroutineContext coroutineContext, Object obj, Object obj2, Function2 function2, Continuation continuation) {
+        Object coroutine_suspended;
+        Object updateThreadContext = ThreadContextKt.updateThreadContext(coroutineContext, obj2);
+        try {
+            Object invoke = ((Function2) TypeIntrinsics.beforeCheckcastToFunctionOfArity(function2, 2)).invoke(obj, new StackFrameContinuation(continuation, coroutineContext));
+            ThreadContextKt.restoreThreadContext(coroutineContext, updateThreadContext);
+            coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+            if (invoke == coroutine_suspended) {
+                DebugProbesKt.probeCoroutineSuspended(continuation);
+            }
+            return invoke;
+        } catch (Throwable th) {
+            ThreadContextKt.restoreThreadContext(coroutineContext, updateThreadContext);
+            throw th;
+        }
+    }
+
+    public static final FlowCollector withUndispatchedContextCollector(FlowCollector flowCollector, CoroutineContext coroutineContext) {
+        return ((flowCollector instanceof SendingCollector) || (flowCollector instanceof NopCollector)) ? flowCollector : new UndispatchedContextCollector(flowCollector, coroutineContext);
+    }
+
+    public static /* synthetic */ Object withContextUndispatched$default(CoroutineContext coroutineContext, Object obj, Object obj2, Function2 function2, Continuation continuation, int i, Object obj3) {
+        if ((i & 4) != 0) {
+            obj2 = ThreadContextKt.threadContextElements(coroutineContext);
+        }
+        return withContextUndispatched(coroutineContext, obj, obj2, function2, continuation);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/ChannelFlowOperator$collectWithContextUndispatched$2.java

@@ -0,0 +1,56 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.flow.FlowCollector;
+
+/* loaded from: classes5.dex */
+public final class ChannelFlowOperator$collectWithContextUndispatched$2 extends SuspendLambda implements Function2 {
+    public /* synthetic */ Object L$0;
+    public int label;
+    public final /* synthetic */ ChannelFlowOperator this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public ChannelFlowOperator$collectWithContextUndispatched$2(ChannelFlowOperator channelFlowOperator, Continuation continuation) {
+        super(2, continuation);
+        this.this$0 = channelFlowOperator;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        ChannelFlowOperator$collectWithContextUndispatched$2 channelFlowOperator$collectWithContextUndispatched$2 = new ChannelFlowOperator$collectWithContextUndispatched$2(this.this$0, continuation);
+        channelFlowOperator$collectWithContextUndispatched$2.L$0 = obj;
+        return channelFlowOperator$collectWithContextUndispatched$2;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(FlowCollector flowCollector, Continuation continuation) {
+        return ((ChannelFlowOperator$collectWithContextUndispatched$2) create(flowCollector, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended;
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.label;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            FlowCollector flowCollector = (FlowCollector) this.L$0;
+            ChannelFlowOperator channelFlowOperator = this.this$0;
+            this.label = 1;
+            if (channelFlowOperator.flowCollect(flowCollector, 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;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/ChannelFlowOperator.java

@@ -0,0 +1,80 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.ContinuationInterceptor;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.CoroutineContextKt;
+import kotlinx.coroutines.channels.BufferOverflow;
+import kotlinx.coroutines.channels.ProducerScope;
+import kotlinx.coroutines.flow.Flow;
+import kotlinx.coroutines.flow.FlowCollector;
+
+/* loaded from: classes5.dex */
+public abstract class ChannelFlowOperator extends ChannelFlow {
+    public final Flow flow;
+
+    @Override // kotlinx.coroutines.flow.internal.ChannelFlow, kotlinx.coroutines.flow.Flow
+    public Object collect(FlowCollector flowCollector, Continuation continuation) {
+        return collect$suspendImpl(this, flowCollector, continuation);
+    }
+
+    @Override // kotlinx.coroutines.flow.internal.ChannelFlow
+    public Object collectTo(ProducerScope producerScope, Continuation continuation) {
+        return collectTo$suspendImpl(this, producerScope, continuation);
+    }
+
+    public abstract Object flowCollect(FlowCollector flowCollector, Continuation continuation);
+
+    public ChannelFlowOperator(Flow flow, CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow) {
+        super(coroutineContext, i, bufferOverflow);
+        this.flow = flow;
+    }
+
+    public final Object collectWithContextUndispatched(FlowCollector flowCollector, CoroutineContext coroutineContext, Continuation continuation) {
+        FlowCollector withUndispatchedContextCollector;
+        Object coroutine_suspended;
+        withUndispatchedContextCollector = ChannelFlowKt.withUndispatchedContextCollector(flowCollector, continuation.getContext());
+        Object withContextUndispatched$default = ChannelFlowKt.withContextUndispatched$default(coroutineContext, withUndispatchedContextCollector, null, new ChannelFlowOperator$collectWithContextUndispatched$2(this, null), continuation, 4, null);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return withContextUndispatched$default == coroutine_suspended ? withContextUndispatched$default : Unit.INSTANCE;
+    }
+
+    public static /* synthetic */ Object collectTo$suspendImpl(ChannelFlowOperator channelFlowOperator, ProducerScope producerScope, Continuation continuation) {
+        Object coroutine_suspended;
+        Object flowCollect = channelFlowOperator.flowCollect(new SendingCollector(producerScope), continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return flowCollect == coroutine_suspended ? flowCollect : Unit.INSTANCE;
+    }
+
+    public static /* synthetic */ Object collect$suspendImpl(ChannelFlowOperator channelFlowOperator, FlowCollector flowCollector, Continuation continuation) {
+        Object coroutine_suspended;
+        Object coroutine_suspended2;
+        Object coroutine_suspended3;
+        if (channelFlowOperator.capacity == -3) {
+            CoroutineContext context = continuation.getContext();
+            CoroutineContext newCoroutineContext = CoroutineContextKt.newCoroutineContext(context, channelFlowOperator.context);
+            if (Intrinsics.areEqual(newCoroutineContext, context)) {
+                Object flowCollect = channelFlowOperator.flowCollect(flowCollector, continuation);
+                coroutine_suspended3 = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+                return flowCollect == coroutine_suspended3 ? flowCollect : Unit.INSTANCE;
+            }
+            ContinuationInterceptor.Key key = ContinuationInterceptor.Key;
+            if (Intrinsics.areEqual(newCoroutineContext.get(key), context.get(key))) {
+                Object collectWithContextUndispatched = channelFlowOperator.collectWithContextUndispatched(flowCollector, newCoroutineContext, continuation);
+                coroutine_suspended2 = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+                return collectWithContextUndispatched == coroutine_suspended2 ? collectWithContextUndispatched : Unit.INSTANCE;
+            }
+        }
+        Object collect = super.collect(flowCollector, continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return collect == coroutine_suspended ? collect : Unit.INSTANCE;
+    }
+
+    @Override // kotlinx.coroutines.flow.internal.ChannelFlow
+    public String toString() {
+        return this.flow + " -> " + super.toString();
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/ChannelFlowOperatorImpl.java

@@ -0,0 +1,40 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.coroutines.EmptyCoroutineContext;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlinx.coroutines.channels.BufferOverflow;
+import kotlinx.coroutines.flow.Flow;
+import kotlinx.coroutines.flow.FlowCollector;
+
+/* loaded from: classes5.dex */
+public final class ChannelFlowOperatorImpl extends ChannelFlowOperator {
+    @Override // kotlinx.coroutines.flow.internal.ChannelFlow
+    public Flow dropChannelOperators() {
+        return this.flow;
+    }
+
+    public /* synthetic */ ChannelFlowOperatorImpl(Flow flow, CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow, int i2, DefaultConstructorMarker defaultConstructorMarker) {
+        this(flow, (i2 & 2) != 0 ? EmptyCoroutineContext.INSTANCE : coroutineContext, (i2 & 4) != 0 ? -3 : i, (i2 & 8) != 0 ? BufferOverflow.SUSPEND : bufferOverflow);
+    }
+
+    public ChannelFlowOperatorImpl(Flow flow, CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow) {
+        super(flow, coroutineContext, i, bufferOverflow);
+    }
+
+    @Override // kotlinx.coroutines.flow.internal.ChannelFlow
+    public ChannelFlow create(CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow) {
+        return new ChannelFlowOperatorImpl(this.flow, coroutineContext, i, bufferOverflow);
+    }
+
+    @Override // kotlinx.coroutines.flow.internal.ChannelFlowOperator
+    public Object flowCollect(FlowCollector flowCollector, Continuation continuation) {
+        Object coroutine_suspended;
+        Object collect = this.flow.collect(flowCollector, continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return collect == coroutine_suspended ? collect : Unit.INSTANCE;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/ChannelFlowTransformLatest$flowCollect$3$1$emit$1.java

@@ -0,0 +1,28 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlinx.coroutines.flow.internal.ChannelFlowTransformLatest$flowCollect$3;
+
+/* loaded from: classes5.dex */
+public final class ChannelFlowTransformLatest$flowCollect$3$1$emit$1 extends ContinuationImpl {
+    public Object L$0;
+    public Object L$1;
+    public Object L$2;
+    public int label;
+    public /* synthetic */ Object result;
+    public final /* synthetic */ ChannelFlowTransformLatest$flowCollect$3.AnonymousClass1 this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public ChannelFlowTransformLatest$flowCollect$3$1$emit$1(ChannelFlowTransformLatest$flowCollect$3.AnonymousClass1 anonymousClass1, Continuation continuation) {
+        super(continuation);
+        this.this$0 = anonymousClass1;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        this.result = obj;
+        this.label |= Integer.MIN_VALUE;
+        return this.this$0.emit(null, this);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/ChannelFlowTransformLatest$flowCollect$3.java

@@ -0,0 +1,211 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.functions.Function3;
+import kotlin.jvm.internal.Ref;
+import kotlinx.coroutines.CoroutineScope;
+import kotlinx.coroutines.flow.Flow;
+import kotlinx.coroutines.flow.FlowCollector;
+
+/* loaded from: classes5.dex */
+public final class ChannelFlowTransformLatest$flowCollect$3 extends SuspendLambda implements Function2 {
+    public final /* synthetic */ FlowCollector $collector;
+    public /* synthetic */ Object L$0;
+    public int label;
+    public final /* synthetic */ ChannelFlowTransformLatest this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public ChannelFlowTransformLatest$flowCollect$3(ChannelFlowTransformLatest channelFlowTransformLatest, FlowCollector flowCollector, Continuation continuation) {
+        super(2, continuation);
+        this.this$0 = channelFlowTransformLatest;
+        this.$collector = flowCollector;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        ChannelFlowTransformLatest$flowCollect$3 channelFlowTransformLatest$flowCollect$3 = new ChannelFlowTransformLatest$flowCollect$3(this.this$0, this.$collector, continuation);
+        channelFlowTransformLatest$flowCollect$3.L$0 = obj;
+        return channelFlowTransformLatest$flowCollect$3;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(CoroutineScope coroutineScope, Continuation continuation) {
+        return ((ChannelFlowTransformLatest$flowCollect$3) create(coroutineScope, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended;
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.label;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            CoroutineScope coroutineScope = (CoroutineScope) this.L$0;
+            Ref.ObjectRef objectRef = new Ref.ObjectRef();
+            ChannelFlowTransformLatest channelFlowTransformLatest = this.this$0;
+            Flow flow = channelFlowTransformLatest.flow;
+            AnonymousClass1 anonymousClass1 = new AnonymousClass1(objectRef, coroutineScope, channelFlowTransformLatest, this.$collector);
+            this.label = 1;
+            if (flow.collect(anonymousClass1, 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;
+    }
+
+    /* renamed from: kotlinx.coroutines.flow.internal.ChannelFlowTransformLatest$flowCollect$3$1, reason: invalid class name */
+    public static final class AnonymousClass1 implements FlowCollector {
+        public final /* synthetic */ CoroutineScope $$this$coroutineScope;
+        public final /* synthetic */ FlowCollector $collector;
+        public final /* synthetic */ Ref.ObjectRef $previousFlow;
+        public final /* synthetic */ ChannelFlowTransformLatest this$0;
+
+        public AnonymousClass1(Ref.ObjectRef objectRef, CoroutineScope coroutineScope, ChannelFlowTransformLatest channelFlowTransformLatest, FlowCollector flowCollector) {
+            this.$previousFlow = objectRef;
+            this.$$this$coroutineScope = coroutineScope;
+            this.this$0 = channelFlowTransformLatest;
+            this.$collector = flowCollector;
+        }
+
+        /* JADX WARN: Removed duplicated region for block: B:15:0x003b  */
+        /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+        /* JADX WARN: Type inference failed for: r8v2, types: [T, kotlinx.coroutines.Job] */
+        @Override // kotlinx.coroutines.flow.FlowCollector
+        /*
+            Code decompiled incorrectly, please refer to instructions dump.
+            To view partially-correct add '--show-bad-code' argument
+        */
+        public final java.lang.Object emit(java.lang.Object r8, kotlin.coroutines.Continuation r9) {
+            /*
+                r7 = this;
+                boolean r0 = r9 instanceof kotlinx.coroutines.flow.internal.ChannelFlowTransformLatest$flowCollect$3$1$emit$1
+                if (r0 == 0) goto L13
+                r0 = r9
+                kotlinx.coroutines.flow.internal.ChannelFlowTransformLatest$flowCollect$3$1$emit$1 r0 = (kotlinx.coroutines.flow.internal.ChannelFlowTransformLatest$flowCollect$3$1$emit$1) r0
+                int r1 = r0.label
+                r2 = -2147483648(0xffffffff80000000, float:-0.0)
+                r3 = r1 & r2
+                if (r3 == 0) goto L13
+                int r1 = r1 - r2
+                r0.label = r1
+                goto L18
+            L13:
+                kotlinx.coroutines.flow.internal.ChannelFlowTransformLatest$flowCollect$3$1$emit$1 r0 = new kotlinx.coroutines.flow.internal.ChannelFlowTransformLatest$flowCollect$3$1$emit$1
+                r0.<init>(r7, r9)
+            L18:
+                java.lang.Object r9 = r0.result
+                java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+                int r2 = r0.label
+                r3 = 1
+                if (r2 == 0) goto L3b
+                if (r2 != r3) goto L33
+                java.lang.Object r8 = r0.L$2
+                kotlinx.coroutines.Job r8 = (kotlinx.coroutines.Job) r8
+                java.lang.Object r8 = r0.L$1
+                java.lang.Object r0 = r0.L$0
+                kotlinx.coroutines.flow.internal.ChannelFlowTransformLatest$flowCollect$3$1 r0 = (kotlinx.coroutines.flow.internal.ChannelFlowTransformLatest$flowCollect$3.AnonymousClass1) r0
+                kotlin.ResultKt.throwOnFailure(r9)
+                goto L5e
+            L33:
+                java.lang.IllegalStateException r8 = new java.lang.IllegalStateException
+                java.lang.String r9 = "call to 'resume' before 'invoke' with coroutine"
+                r8.<init>(r9)
+                throw r8
+            L3b:
+                kotlin.ResultKt.throwOnFailure(r9)
+                kotlin.jvm.internal.Ref$ObjectRef r9 = r7.$previousFlow
+                T r9 = r9.element
+                kotlinx.coroutines.Job r9 = (kotlinx.coroutines.Job) r9
+                if (r9 == 0) goto L5d
+                kotlinx.coroutines.flow.internal.ChildCancelledException r2 = new kotlinx.coroutines.flow.internal.ChildCancelledException
+                r2.<init>()
+                r9.cancel(r2)
+                r0.L$0 = r7
+                r0.L$1 = r8
+                r0.L$2 = r9
+                r0.label = r3
+                java.lang.Object r9 = r9.join(r0)
+                if (r9 != r1) goto L5d
+                return r1
+            L5d:
+                r0 = r7
+            L5e:
+                kotlin.jvm.internal.Ref$ObjectRef r9 = r0.$previousFlow
+                kotlinx.coroutines.CoroutineScope r1 = r0.$$this$coroutineScope
+                r2 = 0
+                kotlinx.coroutines.CoroutineStart r3 = kotlinx.coroutines.CoroutineStart.UNDISPATCHED
+                kotlinx.coroutines.flow.internal.ChannelFlowTransformLatest$flowCollect$3$1$2 r4 = new kotlinx.coroutines.flow.internal.ChannelFlowTransformLatest$flowCollect$3$1$2
+                kotlinx.coroutines.flow.internal.ChannelFlowTransformLatest r5 = r0.this$0
+                kotlinx.coroutines.flow.FlowCollector r0 = r0.$collector
+                r6 = 0
+                r4.<init>(r5, r0, r8, r6)
+                r5 = 1
+                kotlinx.coroutines.Job r8 = kotlinx.coroutines.BuildersKt.launch$default(r1, r2, r3, r4, r5, r6)
+                r9.element = r8
+                kotlin.Unit r8 = kotlin.Unit.INSTANCE
+                return r8
+            */
+            throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.internal.ChannelFlowTransformLatest$flowCollect$3.AnonymousClass1.emit(java.lang.Object, kotlin.coroutines.Continuation):java.lang.Object");
+        }
+
+        /* renamed from: kotlinx.coroutines.flow.internal.ChannelFlowTransformLatest$flowCollect$3$1$2, reason: invalid class name */
+        public static final class AnonymousClass2 extends SuspendLambda implements Function2 {
+            public final /* synthetic */ FlowCollector $collector;
+            public final /* synthetic */ Object $value;
+            public int label;
+            public final /* synthetic */ ChannelFlowTransformLatest this$0;
+
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            public AnonymousClass2(ChannelFlowTransformLatest channelFlowTransformLatest, FlowCollector flowCollector, Object obj, Continuation continuation) {
+                super(2, continuation);
+                this.this$0 = channelFlowTransformLatest;
+                this.$collector = flowCollector;
+                this.$value = obj;
+            }
+
+            @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+            public final Continuation create(Object obj, Continuation continuation) {
+                return new AnonymousClass2(this.this$0, this.$collector, this.$value, continuation);
+            }
+
+            @Override // kotlin.jvm.functions.Function2
+            public final Object invoke(CoroutineScope coroutineScope, Continuation continuation) {
+                return ((AnonymousClass2) create(coroutineScope, continuation)).invokeSuspend(Unit.INSTANCE);
+            }
+
+            @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+            public final Object invokeSuspend(Object obj) {
+                Object coroutine_suspended;
+                Function3 function3;
+                coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+                int i = this.label;
+                if (i == 0) {
+                    ResultKt.throwOnFailure(obj);
+                    function3 = this.this$0.transform;
+                    FlowCollector flowCollector = this.$collector;
+                    Object obj2 = this.$value;
+                    this.label = 1;
+                    if (function3.invoke(flowCollector, obj2, 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;
+            }
+        }
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/ChannelFlowTransformLatest.java

@@ -0,0 +1,40 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.coroutines.EmptyCoroutineContext;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.jvm.functions.Function3;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlinx.coroutines.CoroutineScopeKt;
+import kotlinx.coroutines.channels.BufferOverflow;
+import kotlinx.coroutines.flow.Flow;
+import kotlinx.coroutines.flow.FlowCollector;
+
+/* loaded from: classes5.dex */
+public final class ChannelFlowTransformLatest extends ChannelFlowOperator {
+    public final Function3 transform;
+
+    public /* synthetic */ ChannelFlowTransformLatest(Function3 function3, Flow flow, CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow, int i2, DefaultConstructorMarker defaultConstructorMarker) {
+        this(function3, flow, (i2 & 4) != 0 ? EmptyCoroutineContext.INSTANCE : coroutineContext, (i2 & 8) != 0 ? -2 : i, (i2 & 16) != 0 ? BufferOverflow.SUSPEND : bufferOverflow);
+    }
+
+    public ChannelFlowTransformLatest(Function3 function3, Flow flow, CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow) {
+        super(flow, coroutineContext, i, bufferOverflow);
+        this.transform = function3;
+    }
+
+    @Override // kotlinx.coroutines.flow.internal.ChannelFlow
+    public ChannelFlow create(CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow) {
+        return new ChannelFlowTransformLatest(this.transform, this.flow, coroutineContext, i, bufferOverflow);
+    }
+
+    @Override // kotlinx.coroutines.flow.internal.ChannelFlowOperator
+    public Object flowCollect(FlowCollector flowCollector, Continuation continuation) {
+        Object coroutine_suspended;
+        Object coroutineScope = CoroutineScopeKt.coroutineScope(new ChannelFlowTransformLatest$flowCollect$3(this, flowCollector, null), continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return coroutineScope == coroutine_suspended ? coroutineScope : Unit.INSTANCE;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/ChildCancelledException.java

@@ -0,0 +1,16 @@
+package kotlinx.coroutines.flow.internal;
+
+import java.util.concurrent.CancellationException;
+
+/* loaded from: classes5.dex */
+public final class ChildCancelledException extends CancellationException {
+    public ChildCancelledException() {
+        super("Child of the scoped flow was cancelled");
+    }
+
+    @Override // java.lang.Throwable
+    public Throwable fillInStackTrace() {
+        setStackTrace(new StackTraceElement[0]);
+        return this;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/CombineKt$combineInternal$2$1$1$emit$1.java

@@ -0,0 +1,25 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlinx.coroutines.flow.internal.CombineKt$combineInternal$2;
+
+/* loaded from: classes5.dex */
+public final class CombineKt$combineInternal$2$1$1$emit$1 extends ContinuationImpl {
+    public int label;
+    public /* synthetic */ Object result;
+    public final /* synthetic */ CombineKt$combineInternal$2.AnonymousClass1.C02571 this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CombineKt$combineInternal$2$1$1$emit$1(CombineKt$combineInternal$2.AnonymousClass1.C02571 c02571, Continuation continuation) {
+        super(continuation);
+        this.this$0 = c02571;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        this.result = obj;
+        this.label |= Integer.MIN_VALUE;
+        return this.this$0.emit(null, this);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/CombineKt$combineInternal$2.java

@@ -0,0 +1,212 @@
+package kotlinx.coroutines.flow.internal;
+
+import java.util.concurrent.atomic.AtomicInteger;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.functions.Function3;
+import kotlinx.coroutines.CoroutineScope;
+import kotlinx.coroutines.channels.Channel;
+import kotlinx.coroutines.channels.SendChannel;
+import kotlinx.coroutines.flow.Flow;
+import kotlinx.coroutines.flow.FlowCollector;
+
+/* loaded from: classes5.dex */
+public final class CombineKt$combineInternal$2 extends SuspendLambda implements Function2 {
+    public final /* synthetic */ Function0 $arrayFactory;
+    public final /* synthetic */ Flow[] $flows;
+    public final /* synthetic */ FlowCollector $this_combineInternal;
+    public final /* synthetic */ Function3 $transform;
+    public int I$0;
+    public int I$1;
+    public /* synthetic */ Object L$0;
+    public Object L$1;
+    public Object L$2;
+    public int label;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CombineKt$combineInternal$2(Flow[] flowArr, Function0 function0, Function3 function3, FlowCollector flowCollector, Continuation continuation) {
+        super(2, continuation);
+        this.$flows = flowArr;
+        this.$arrayFactory = function0;
+        this.$transform = function3;
+        this.$this_combineInternal = flowCollector;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        CombineKt$combineInternal$2 combineKt$combineInternal$2 = new CombineKt$combineInternal$2(this.$flows, this.$arrayFactory, this.$transform, this.$this_combineInternal, continuation);
+        combineKt$combineInternal$2.L$0 = obj;
+        return combineKt$combineInternal$2;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(CoroutineScope coroutineScope, Continuation continuation) {
+        return ((CombineKt$combineInternal$2) create(coroutineScope, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Removed duplicated region for block: B:15:0x00e3  */
+    /* JADX WARN: Removed duplicated region for block: B:17:0x00e6 A[LOOP:0: B:17:0x00e6->B:38:?, LOOP_START, PHI: r6 r10
+  0x00e6: PHI (r6v6 int) = (r6v5 int), (r6v7 int) binds: [B:14:0x00e1, B:38:?] A[DONT_GENERATE, DONT_INLINE]
+  0x00e6: PHI (r10v8 kotlin.collections.IndexedValue) = (r10v7 kotlin.collections.IndexedValue), (r10v21 kotlin.collections.IndexedValue) binds: [B:14:0x00e1, B:38:?] A[DONT_GENERATE, DONT_INLINE]] */
+    /* JADX WARN: Type inference failed for: r2v12, types: [int] */
+    /* JADX WARN: Type inference failed for: r2v7, types: [int] */
+    /* JADX WARN: Type inference failed for: r2v9, types: [int] */
+    /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:30:0x012e -> B:8:0x00c3). Please report as a decompilation issue!!! */
+    @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 r23) {
+        /*
+            Method dump skipped, instructions count: 357
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.internal.CombineKt$combineInternal$2.invokeSuspend(java.lang.Object):java.lang.Object");
+    }
+
+    /* renamed from: kotlinx.coroutines.flow.internal.CombineKt$combineInternal$2$1, reason: invalid class name */
+    public static final class AnonymousClass1 extends SuspendLambda implements Function2 {
+        public final /* synthetic */ Flow[] $flows;
+        public final /* synthetic */ int $i;
+        public final /* synthetic */ AtomicInteger $nonClosed;
+        public final /* synthetic */ Channel $resultChannel;
+        public int label;
+
+        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+        public AnonymousClass1(Flow[] flowArr, int i, AtomicInteger atomicInteger, Channel channel, Continuation continuation) {
+            super(2, continuation);
+            this.$flows = flowArr;
+            this.$i = i;
+            this.$nonClosed = atomicInteger;
+            this.$resultChannel = channel;
+        }
+
+        @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+        public final Continuation create(Object obj, Continuation continuation) {
+            return new AnonymousClass1(this.$flows, this.$i, this.$nonClosed, this.$resultChannel, continuation);
+        }
+
+        @Override // kotlin.jvm.functions.Function2
+        public final Object invoke(CoroutineScope coroutineScope, Continuation continuation) {
+            return ((AnonymousClass1) create(coroutineScope, continuation)).invokeSuspend(Unit.INSTANCE);
+        }
+
+        @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+        public final Object invokeSuspend(Object obj) {
+            Object coroutine_suspended;
+            AtomicInteger atomicInteger;
+            coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+            int i = this.label;
+            try {
+                if (i == 0) {
+                    ResultKt.throwOnFailure(obj);
+                    Flow[] flowArr = this.$flows;
+                    int i2 = this.$i;
+                    Flow flow = flowArr[i2];
+                    C02571 c02571 = new C02571(this.$resultChannel, i2);
+                    this.label = 1;
+                    if (flow.collect(c02571, this) == coroutine_suspended) {
+                        return coroutine_suspended;
+                    }
+                } else {
+                    if (i != 1) {
+                        throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+                    }
+                    ResultKt.throwOnFailure(obj);
+                }
+                if (atomicInteger.decrementAndGet() == 0) {
+                    SendChannel.DefaultImpls.close$default(this.$resultChannel, null, 1, null);
+                }
+                return Unit.INSTANCE;
+            } finally {
+                if (this.$nonClosed.decrementAndGet() == 0) {
+                    SendChannel.DefaultImpls.close$default(this.$resultChannel, null, 1, null);
+                }
+            }
+        }
+
+        /* renamed from: kotlinx.coroutines.flow.internal.CombineKt$combineInternal$2$1$1, reason: invalid class name and collision with other inner class name */
+        public static final class C02571 implements FlowCollector {
+            public final /* synthetic */ int $i;
+            public final /* synthetic */ Channel $resultChannel;
+
+            public C02571(Channel channel, int i) {
+                this.$resultChannel = channel;
+                this.$i = i;
+            }
+
+            /* JADX WARN: Removed duplicated region for block: B:19:0x0055 A[RETURN] */
+            /* JADX WARN: Removed duplicated region for block: B:20:0x0038  */
+            /* JADX WARN: Removed duplicated region for block: B:8:0x0024  */
+            @Override // kotlinx.coroutines.flow.FlowCollector
+            /*
+                Code decompiled incorrectly, please refer to instructions dump.
+                To view partially-correct add '--show-bad-code' argument
+            */
+            public final java.lang.Object emit(java.lang.Object r7, kotlin.coroutines.Continuation r8) {
+                /*
+                    r6 = this;
+                    boolean r0 = r8 instanceof kotlinx.coroutines.flow.internal.CombineKt$combineInternal$2$1$1$emit$1
+                    if (r0 == 0) goto L13
+                    r0 = r8
+                    kotlinx.coroutines.flow.internal.CombineKt$combineInternal$2$1$1$emit$1 r0 = (kotlinx.coroutines.flow.internal.CombineKt$combineInternal$2$1$1$emit$1) r0
+                    int r1 = r0.label
+                    r2 = -2147483648(0xffffffff80000000, float:-0.0)
+                    r3 = r1 & r2
+                    if (r3 == 0) goto L13
+                    int r1 = r1 - r2
+                    r0.label = r1
+                    goto L18
+                L13:
+                    kotlinx.coroutines.flow.internal.CombineKt$combineInternal$2$1$1$emit$1 r0 = new kotlinx.coroutines.flow.internal.CombineKt$combineInternal$2$1$1$emit$1
+                    r0.<init>(r6, r8)
+                L18:
+                    java.lang.Object r8 = r0.result
+                    java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+                    int r2 = r0.label
+                    r3 = 2
+                    r4 = 1
+                    if (r2 == 0) goto L38
+                    if (r2 == r4) goto L34
+                    if (r2 != r3) goto L2c
+                    kotlin.ResultKt.throwOnFailure(r8)
+                    goto L56
+                L2c:
+                    java.lang.IllegalStateException r7 = new java.lang.IllegalStateException
+                    java.lang.String r8 = "call to 'resume' before 'invoke' with coroutine"
+                    r7.<init>(r8)
+                    throw r7
+                L34:
+                    kotlin.ResultKt.throwOnFailure(r8)
+                    goto L4d
+                L38:
+                    kotlin.ResultKt.throwOnFailure(r8)
+                    kotlinx.coroutines.channels.Channel r8 = r6.$resultChannel
+                    kotlin.collections.IndexedValue r2 = new kotlin.collections.IndexedValue
+                    int r5 = r6.$i
+                    r2.<init>(r5, r7)
+                    r0.label = r4
+                    java.lang.Object r7 = r8.send(r2, r0)
+                    if (r7 != r1) goto L4d
+                    return r1
+                L4d:
+                    r0.label = r3
+                    java.lang.Object r7 = kotlinx.coroutines.YieldKt.yield(r0)
+                    if (r7 != r1) goto L56
+                    return r1
+                L56:
+                    kotlin.Unit r7 = kotlin.Unit.INSTANCE
+                    return r7
+                */
+                throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.internal.CombineKt$combineInternal$2.AnonymousClass1.C02571.emit(java.lang.Object, kotlin.coroutines.Continuation):java.lang.Object");
+            }
+        }
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/CombineKt.java

@@ -0,0 +1,19 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function3;
+import kotlinx.coroutines.flow.Flow;
+import kotlinx.coroutines.flow.FlowCollector;
+
+/* loaded from: classes5.dex */
+public abstract class CombineKt {
+    public static final Object combineInternal(FlowCollector flowCollector, Flow[] flowArr, Function0 function0, Function3 function3, Continuation continuation) {
+        Object coroutine_suspended;
+        Object flowScope = FlowCoroutineKt.flowScope(new CombineKt$combineInternal$2(flowArr, function0, function3, flowCollector, null), continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return flowScope == coroutine_suspended ? flowScope : Unit.INSTANCE;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/DownstreamExceptionContext.java

@@ -0,0 +1,35 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.coroutines.CoroutineContext;
+import kotlin.jvm.functions.Function2;
+
+/* loaded from: classes5.dex */
+public final class DownstreamExceptionContext implements CoroutineContext {
+    public final /* synthetic */ CoroutineContext $$delegate_0;
+    public final Throwable e;
+
+    @Override // kotlin.coroutines.CoroutineContext
+    public Object fold(Object obj, Function2 function2) {
+        return this.$$delegate_0.fold(obj, function2);
+    }
+
+    @Override // kotlin.coroutines.CoroutineContext
+    public CoroutineContext.Element get(CoroutineContext.Key key) {
+        return this.$$delegate_0.get(key);
+    }
+
+    @Override // kotlin.coroutines.CoroutineContext
+    public CoroutineContext minusKey(CoroutineContext.Key key) {
+        return this.$$delegate_0.minusKey(key);
+    }
+
+    @Override // kotlin.coroutines.CoroutineContext
+    public CoroutineContext plus(CoroutineContext coroutineContext) {
+        return this.$$delegate_0.plus(coroutineContext);
+    }
+
+    public DownstreamExceptionContext(Throwable th, CoroutineContext coroutineContext) {
+        this.e = th;
+        this.$$delegate_0 = coroutineContext;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/FlowCoroutine.java

@@ -0,0 +1,20 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+import kotlinx.coroutines.internal.ScopeCoroutine;
+
+/* loaded from: classes5.dex */
+public final class FlowCoroutine extends ScopeCoroutine {
+    public FlowCoroutine(CoroutineContext coroutineContext, Continuation continuation) {
+        super(coroutineContext, continuation);
+    }
+
+    @Override // kotlinx.coroutines.JobSupport
+    public boolean childCancelled(Throwable th) {
+        if (th instanceof ChildCancelledException) {
+            return true;
+        }
+        return cancelImpl$kotlinx_coroutines_core(th);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/FlowCoroutineKt.java

@@ -0,0 +1,21 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.DebugProbesKt;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.intrinsics.UndispatchedKt;
+
+/* loaded from: classes5.dex */
+public abstract class FlowCoroutineKt {
+    public static final Object flowScope(Function2 function2, Continuation continuation) {
+        Object coroutine_suspended;
+        FlowCoroutine flowCoroutine = new FlowCoroutine(continuation.getContext(), continuation);
+        Object startUndispatchedOrReturn = UndispatchedKt.startUndispatchedOrReturn(flowCoroutine, flowCoroutine, function2);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        if (startUndispatchedOrReturn == coroutine_suspended) {
+            DebugProbesKt.probeCoroutineSuspended(continuation);
+        }
+        return startUndispatchedOrReturn;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/FlowExceptions_commonKt.java

@@ -0,0 +1,12 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlinx.coroutines.flow.FlowCollector;
+
+/* loaded from: classes5.dex */
+public abstract class FlowExceptions_commonKt {
+    public static final void checkOwnership(AbortFlowException abortFlowException, FlowCollector flowCollector) {
+        if (abortFlowException.owner != flowCollector) {
+            throw abortFlowException;
+        }
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/FusibleFlow.java

@@ -0,0 +1,29 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.coroutines.CoroutineContext;
+import kotlin.coroutines.EmptyCoroutineContext;
+import kotlinx.coroutines.channels.BufferOverflow;
+import kotlinx.coroutines.flow.Flow;
+
+/* loaded from: classes5.dex */
+public interface FusibleFlow extends Flow {
+    Flow fuse(CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow);
+
+    public static final class DefaultImpls {
+        public static /* synthetic */ Flow fuse$default(FusibleFlow fusibleFlow, CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow, int i2, Object obj) {
+            if (obj != null) {
+                throw new UnsupportedOperationException("Super calls with default arguments not supported in this target, function: fuse");
+            }
+            if ((i2 & 1) != 0) {
+                coroutineContext = EmptyCoroutineContext.INSTANCE;
+            }
+            if ((i2 & 2) != 0) {
+                i = -3;
+            }
+            if ((i2 & 4) != 0) {
+                bufferOverflow = BufferOverflow.SUSPEND;
+            }
+            return fusibleFlow.fuse(coroutineContext, i, bufferOverflow);
+        }
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/NoOpContinuation.java

@@ -0,0 +1,20 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.coroutines.EmptyCoroutineContext;
+
+/* loaded from: classes5.dex */
+public final class NoOpContinuation implements Continuation {
+    public static final NoOpContinuation INSTANCE = new NoOpContinuation();
+    public static final CoroutineContext context = EmptyCoroutineContext.INSTANCE;
+
+    @Override // kotlin.coroutines.Continuation
+    public CoroutineContext getContext() {
+        return context;
+    }
+
+    @Override // kotlin.coroutines.Continuation
+    public void resumeWith(Object obj) {
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/NopCollector.java

@@ -0,0 +1,15 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlinx.coroutines.flow.FlowCollector;
+
+/* loaded from: classes5.dex */
+public final class NopCollector implements FlowCollector {
+    public static final NopCollector INSTANCE = new NopCollector();
+
+    @Override // kotlinx.coroutines.flow.FlowCollector
+    public Object emit(Object obj, Continuation continuation) {
+        return Unit.INSTANCE;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/NullSurrogateKt.java

@@ -0,0 +1,10 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlinx.coroutines.internal.Symbol;
+
+/* loaded from: classes5.dex */
+public abstract class NullSurrogateKt {
+    public static final Symbol NULL = new Symbol("NULL");
+    public static final Symbol UNINITIALIZED = new Symbol("UNINITIALIZED");
+    public static final Symbol DONE = new Symbol("DONE");
+}

decompiled/sources/kotlinx/coroutines/flow/internal/SafeCollector.java

@@ -0,0 +1,136 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.Result;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.coroutines.EmptyCoroutineContext;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.coroutines.jvm.internal.CoroutineStackFrame;
+import kotlin.coroutines.jvm.internal.DebugProbesKt;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.functions.Function3;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.StringsKt__IndentKt;
+import kotlinx.coroutines.JobKt;
+import kotlinx.coroutines.flow.FlowCollector;
+
+/* loaded from: classes5.dex */
+public final class SafeCollector extends ContinuationImpl implements FlowCollector, CoroutineStackFrame {
+    public final CoroutineContext collectContext;
+    public final int collectContextSize;
+    public final FlowCollector collector;
+    public Continuation completion;
+    public CoroutineContext lastEmissionContext;
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public StackTraceElement getStackTraceElement() {
+        return null;
+    }
+
+    public SafeCollector(FlowCollector flowCollector, CoroutineContext coroutineContext) {
+        super(NoOpContinuation.INSTANCE, EmptyCoroutineContext.INSTANCE);
+        this.collector = flowCollector;
+        this.collectContext = coroutineContext;
+        this.collectContextSize = ((Number) coroutineContext.fold(0, new Function2() { // from class: kotlinx.coroutines.flow.internal.SafeCollector$collectContextSize$1
+            public final Integer invoke(int i, CoroutineContext.Element element) {
+                return Integer.valueOf(i + 1);
+            }
+
+            @Override // kotlin.jvm.functions.Function2
+            public /* bridge */ /* synthetic */ Object invoke(Object obj, Object obj2) {
+                return invoke(((Number) obj).intValue(), (CoroutineContext.Element) obj2);
+            }
+        })).intValue();
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl, kotlin.coroutines.jvm.internal.CoroutineStackFrame
+    public CoroutineStackFrame getCallerFrame() {
+        Continuation continuation = this.completion;
+        if (continuation instanceof CoroutineStackFrame) {
+            return (CoroutineStackFrame) continuation;
+        }
+        return null;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.ContinuationImpl, kotlin.coroutines.Continuation
+    public CoroutineContext getContext() {
+        CoroutineContext coroutineContext = this.lastEmissionContext;
+        return coroutineContext == null ? EmptyCoroutineContext.INSTANCE : coroutineContext;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public Object invokeSuspend(Object obj) {
+        Object coroutine_suspended;
+        Throwable m4062exceptionOrNullimpl = Result.m4062exceptionOrNullimpl(obj);
+        if (m4062exceptionOrNullimpl != null) {
+            this.lastEmissionContext = new DownstreamExceptionContext(m4062exceptionOrNullimpl, getContext());
+        }
+        Continuation continuation = this.completion;
+        if (continuation != null) {
+            continuation.resumeWith(obj);
+        }
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return coroutine_suspended;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.ContinuationImpl, kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public void releaseIntercepted() {
+        super.releaseIntercepted();
+    }
+
+    @Override // kotlinx.coroutines.flow.FlowCollector
+    public Object emit(Object obj, Continuation continuation) {
+        Object coroutine_suspended;
+        Object coroutine_suspended2;
+        try {
+            Object emit = emit(continuation, obj);
+            coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+            if (emit == coroutine_suspended) {
+                DebugProbesKt.probeCoroutineSuspended(continuation);
+            }
+            coroutine_suspended2 = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+            return emit == coroutine_suspended2 ? emit : Unit.INSTANCE;
+        } catch (Throwable th) {
+            this.lastEmissionContext = new DownstreamExceptionContext(th, continuation.getContext());
+            throw th;
+        }
+    }
+
+    public final Object emit(Continuation continuation, Object obj) {
+        Function3 function3;
+        Object coroutine_suspended;
+        CoroutineContext context = continuation.getContext();
+        JobKt.ensureActive(context);
+        CoroutineContext coroutineContext = this.lastEmissionContext;
+        if (coroutineContext != context) {
+            checkContext(context, coroutineContext, obj);
+            this.lastEmissionContext = context;
+        }
+        this.completion = continuation;
+        function3 = SafeCollectorKt.emitFun;
+        FlowCollector flowCollector = this.collector;
+        Intrinsics.checkNotNull(flowCollector, "null cannot be cast to non-null type kotlinx.coroutines.flow.FlowCollector<kotlin.Any?>");
+        Intrinsics.checkNotNull(this, "null cannot be cast to non-null type kotlin.coroutines.Continuation<kotlin.Unit>");
+        Object invoke = function3.invoke(flowCollector, obj, this);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        if (!Intrinsics.areEqual(invoke, coroutine_suspended)) {
+            this.completion = null;
+        }
+        return invoke;
+    }
+
+    public final void checkContext(CoroutineContext coroutineContext, CoroutineContext coroutineContext2, Object obj) {
+        if (coroutineContext2 instanceof DownstreamExceptionContext) {
+            exceptionTransparencyViolated((DownstreamExceptionContext) coroutineContext2, obj);
+        }
+        SafeCollector_commonKt.checkContext(this, coroutineContext);
+    }
+
+    public final void exceptionTransparencyViolated(DownstreamExceptionContext downstreamExceptionContext, Object obj) {
+        String trimIndent;
+        trimIndent = StringsKt__IndentKt.trimIndent("\n            Flow exception transparency is violated:\n                Previous 'emit' call has thrown exception " + downstreamExceptionContext.e + ", but then emission attempt of value '" + obj + "' has been detected.\n                Emissions from 'catch' blocks are prohibited in order to avoid unspecified behaviour, 'Flow.catch' operator can be used instead.\n                For a more detailed explanation, please refer to Flow documentation.\n            ");
+        throw new IllegalStateException(trimIndent.toString());
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/SafeCollectorKt$emitFun$1.java

@@ -0,0 +1,20 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.coroutines.Continuation;
+import kotlin.jvm.functions.Function3;
+import kotlin.jvm.internal.FunctionReferenceImpl;
+import kotlinx.coroutines.flow.FlowCollector;
+
+/* loaded from: classes5.dex */
+public /* synthetic */ class SafeCollectorKt$emitFun$1 extends FunctionReferenceImpl implements Function3 {
+    public static final SafeCollectorKt$emitFun$1 INSTANCE = new SafeCollectorKt$emitFun$1();
+
+    public SafeCollectorKt$emitFun$1() {
+        super(3, FlowCollector.class, "emit", "emit(Ljava/lang/Object;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", 0);
+    }
+
+    @Override // kotlin.jvm.functions.Function3
+    public final Object invoke(FlowCollector flowCollector, Object obj, Continuation continuation) {
+        return flowCollector.emit(obj, continuation);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/SafeCollectorKt.java

@@ -0,0 +1,16 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.jvm.functions.Function3;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.TypeIntrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class SafeCollectorKt {
+    public static final Function3 emitFun;
+
+    static {
+        SafeCollectorKt$emitFun$1 safeCollectorKt$emitFun$1 = SafeCollectorKt$emitFun$1.INSTANCE;
+        Intrinsics.checkNotNull(safeCollectorKt$emitFun$1, "null cannot be cast to non-null type kotlin.Function3<kotlinx.coroutines.flow.FlowCollector<kotlin.Any?>, kotlin.Any?, kotlin.coroutines.Continuation<kotlin.Unit>, kotlin.Any?>");
+        emitFun = (Function3) TypeIntrinsics.beforeCheckcastToFunctionOfArity(safeCollectorKt$emitFun$1, 3);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/SafeCollector_commonKt.java

@@ -0,0 +1,54 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.coroutines.CoroutineContext;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.Job;
+import kotlinx.coroutines.internal.ScopeCoroutine;
+
+/* loaded from: classes5.dex */
+public abstract class SafeCollector_commonKt {
+    public static final void checkContext(final SafeCollector safeCollector, CoroutineContext coroutineContext) {
+        if (((Number) coroutineContext.fold(0, new Function2() { // from class: kotlinx.coroutines.flow.internal.SafeCollector_commonKt$checkContext$result$1
+            {
+                super(2);
+            }
+
+            @Override // kotlin.jvm.functions.Function2
+            public /* bridge */ /* synthetic */ Object invoke(Object obj, Object obj2) {
+                return invoke(((Number) obj).intValue(), (CoroutineContext.Element) obj2);
+            }
+
+            public final Integer invoke(int i, CoroutineContext.Element element) {
+                CoroutineContext.Key key = element.getKey();
+                CoroutineContext.Element element2 = SafeCollector.this.collectContext.get(key);
+                if (key != Job.Key) {
+                    return Integer.valueOf(element != element2 ? Integer.MIN_VALUE : i + 1);
+                }
+                Job job = (Job) element2;
+                Intrinsics.checkNotNull(element, "null cannot be cast to non-null type kotlinx.coroutines.Job");
+                Job transitiveCoroutineParent = SafeCollector_commonKt.transitiveCoroutineParent((Job) element, job);
+                if (transitiveCoroutineParent != job) {
+                    throw new IllegalStateException(("Flow invariant is violated:\n\t\tEmission from another coroutine is detected.\n\t\tChild of " + transitiveCoroutineParent + ", expected child of " + job + ".\n\t\tFlowCollector is not thread-safe and concurrent emissions are prohibited.\n\t\tTo mitigate this restriction please use 'channelFlow' builder instead of 'flow'").toString());
+                }
+                if (job != null) {
+                    i++;
+                }
+                return Integer.valueOf(i);
+            }
+        })).intValue() == safeCollector.collectContextSize) {
+            return;
+        }
+        throw new IllegalStateException(("Flow invariant is violated:\n\t\tFlow was collected in " + safeCollector.collectContext + ",\n\t\tbut emission happened in " + coroutineContext + ".\n\t\tPlease refer to 'flow' documentation or use 'flowOn' instead").toString());
+    }
+
+    public static final Job transitiveCoroutineParent(Job job, Job job2) {
+        while (job != null) {
+            if (job == job2 || !(job instanceof ScopeCoroutine)) {
+                return job;
+            }
+            job = job.getParent();
+        }
+        return null;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/SendingCollector.java

@@ -0,0 +1,24 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlinx.coroutines.channels.SendChannel;
+import kotlinx.coroutines.flow.FlowCollector;
+
+/* loaded from: classes5.dex */
+public final class SendingCollector implements FlowCollector {
+    public final SendChannel channel;
+
+    public SendingCollector(SendChannel sendChannel) {
+        this.channel = sendChannel;
+    }
+
+    @Override // kotlinx.coroutines.flow.FlowCollector
+    public Object emit(Object obj, Continuation continuation) {
+        Object coroutine_suspended;
+        Object send = this.channel.send(obj, continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return send == coroutine_suspended ? send : Unit.INSTANCE;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/StackFrameContinuation.java

@@ -0,0 +1,35 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.coroutines.jvm.internal.CoroutineStackFrame;
+
+/* loaded from: classes5.dex */
+public final class StackFrameContinuation implements Continuation, CoroutineStackFrame {
+    public final CoroutineContext context;
+    public final Continuation uCont;
+
+    @Override // kotlin.coroutines.Continuation
+    public CoroutineContext getContext() {
+        return this.context;
+    }
+
+    public StackFrameContinuation(Continuation continuation, CoroutineContext coroutineContext) {
+        this.uCont = continuation;
+        this.context = coroutineContext;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.CoroutineStackFrame
+    public CoroutineStackFrame getCallerFrame() {
+        Continuation continuation = this.uCont;
+        if (continuation instanceof CoroutineStackFrame) {
+            return (CoroutineStackFrame) continuation;
+        }
+        return null;
+    }
+
+    @Override // kotlin.coroutines.Continuation
+    public void resumeWith(Object obj) {
+        this.uCont.resumeWith(obj);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/SubscriptionCountStateFlow.java

@@ -0,0 +1,30 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlinx.coroutines.channels.BufferOverflow;
+import kotlinx.coroutines.flow.SharedFlowImpl;
+import kotlinx.coroutines.flow.StateFlow;
+
+/* loaded from: classes5.dex */
+public final class SubscriptionCountStateFlow extends SharedFlowImpl implements StateFlow {
+    @Override // kotlinx.coroutines.flow.StateFlow
+    public Integer getValue() {
+        Integer valueOf;
+        synchronized (this) {
+            valueOf = Integer.valueOf(((Number) getLastReplayedLocked()).intValue());
+        }
+        return valueOf;
+    }
+
+    public final boolean increment(int i) {
+        boolean tryEmit;
+        synchronized (this) {
+            tryEmit = tryEmit(Integer.valueOf(((Number) getLastReplayedLocked()).intValue() + i));
+        }
+        return tryEmit;
+    }
+
+    public SubscriptionCountStateFlow(int i) {
+        super(1, Integer.MAX_VALUE, BufferOverflow.DROP_OLDEST);
+        tryEmit(Integer.valueOf(i));
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/UndispatchedContextCollector$emitRef$1.java

@@ -0,0 +1,56 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.flow.FlowCollector;
+
+/* loaded from: classes5.dex */
+public final class UndispatchedContextCollector$emitRef$1 extends SuspendLambda implements Function2 {
+    public final /* synthetic */ FlowCollector $downstream;
+    public /* synthetic */ Object L$0;
+    public int label;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public UndispatchedContextCollector$emitRef$1(FlowCollector flowCollector, Continuation continuation) {
+        super(2, continuation);
+        this.$downstream = flowCollector;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        UndispatchedContextCollector$emitRef$1 undispatchedContextCollector$emitRef$1 = new UndispatchedContextCollector$emitRef$1(this.$downstream, continuation);
+        undispatchedContextCollector$emitRef$1.L$0 = obj;
+        return undispatchedContextCollector$emitRef$1;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Continuation continuation) {
+        return ((UndispatchedContextCollector$emitRef$1) create(obj, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended;
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.label;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            Object obj2 = this.L$0;
+            FlowCollector flowCollector = this.$downstream;
+            this.label = 1;
+            if (flowCollector.emit(obj2, 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;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/internal/UndispatchedContextCollector.java

@@ -0,0 +1,30 @@
+package kotlinx.coroutines.flow.internal;
+
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.flow.FlowCollector;
+import kotlinx.coroutines.internal.ThreadContextKt;
+
+/* loaded from: classes5.dex */
+public final class UndispatchedContextCollector implements FlowCollector {
+    public final Object countOrElement;
+    public final CoroutineContext emitContext;
+    public final Function2 emitRef;
+
+    public UndispatchedContextCollector(FlowCollector flowCollector, CoroutineContext coroutineContext) {
+        this.emitContext = coroutineContext;
+        this.countOrElement = ThreadContextKt.threadContextElements(coroutineContext);
+        this.emitRef = new UndispatchedContextCollector$emitRef$1(flowCollector, null);
+    }
+
+    @Override // kotlinx.coroutines.flow.FlowCollector
+    public Object emit(Object obj, Continuation continuation) {
+        Object coroutine_suspended;
+        Object withContextUndispatched = ChannelFlowKt.withContextUndispatched(this.emitContext, obj, this.countOrElement, this.emitRef, continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return withContextUndispatched == coroutine_suspended ? withContextUndispatched : Unit.INSTANCE;
+    }
+}