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/AbstractFlow$collect$1.java

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

decompiled/sources/kotlinx/coroutines/flow/AbstractFlow.java

@@ -0,0 +1,79 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+
+/* loaded from: classes5.dex */
+public abstract class AbstractFlow implements Flow {
+    public abstract Object collectSafely(FlowCollector flowCollector, Continuation continuation);
+
+    /* JADX WARN: Removed duplicated region for block: B:21:0x0037  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+    @Override // kotlinx.coroutines.flow.Flow
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final java.lang.Object collect(kotlinx.coroutines.flow.FlowCollector r6, kotlin.coroutines.Continuation r7) {
+        /*
+            r5 = this;
+            boolean r0 = r7 instanceof kotlinx.coroutines.flow.AbstractFlow$collect$1
+            if (r0 == 0) goto L13
+            r0 = r7
+            kotlinx.coroutines.flow.AbstractFlow$collect$1 r0 = (kotlinx.coroutines.flow.AbstractFlow$collect$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.AbstractFlow$collect$1 r0 = new kotlinx.coroutines.flow.AbstractFlow$collect$1
+            r0.<init>(r5, r7)
+        L18:
+            java.lang.Object r7 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 1
+            if (r2 == 0) goto L37
+            if (r2 != r3) goto L2f
+            java.lang.Object r6 = r0.L$0
+            kotlinx.coroutines.flow.internal.SafeCollector r6 = (kotlinx.coroutines.flow.internal.SafeCollector) r6
+            kotlin.ResultKt.throwOnFailure(r7)     // Catch: java.lang.Throwable -> L2d
+            goto L4f
+        L2d:
+            r7 = move-exception
+            goto L59
+        L2f:
+            java.lang.IllegalStateException r6 = new java.lang.IllegalStateException
+            java.lang.String r7 = "call to 'resume' before 'invoke' with coroutine"
+            r6.<init>(r7)
+            throw r6
+        L37:
+            kotlin.ResultKt.throwOnFailure(r7)
+            kotlinx.coroutines.flow.internal.SafeCollector r7 = new kotlinx.coroutines.flow.internal.SafeCollector
+            kotlin.coroutines.CoroutineContext r2 = r0.getContext()
+            r7.<init>(r6, r2)
+            r0.L$0 = r7     // Catch: java.lang.Throwable -> L55
+            r0.label = r3     // Catch: java.lang.Throwable -> L55
+            java.lang.Object r6 = r5.collectSafely(r7, r0)     // Catch: java.lang.Throwable -> L55
+            if (r6 != r1) goto L4e
+            return r1
+        L4e:
+            r6 = r7
+        L4f:
+            r6.releaseIntercepted()
+            kotlin.Unit r6 = kotlin.Unit.INSTANCE
+            return r6
+        L55:
+            r6 = move-exception
+            r4 = r7
+            r7 = r6
+            r6 = r4
+        L59:
+            r6.releaseIntercepted()
+            throw r7
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.AbstractFlow.collect(kotlinx.coroutines.flow.FlowCollector, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/CallbackFlowBuilder$collectTo$1.java

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

decompiled/sources/kotlinx/coroutines/flow/CallbackFlowBuilder.java

@@ -0,0 +1,90 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.CoroutineContext;
+import kotlin.coroutines.EmptyCoroutineContext;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlinx.coroutines.channels.BufferOverflow;
+import kotlinx.coroutines.flow.internal.ChannelFlow;
+
+/* loaded from: classes5.dex */
+public final class CallbackFlowBuilder extends ChannelFlowBuilder {
+    public final Function2 block;
+
+    public /* synthetic */ CallbackFlowBuilder(Function2 function2, CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow, int i2, DefaultConstructorMarker defaultConstructorMarker) {
+        this(function2, (i2 & 2) != 0 ? EmptyCoroutineContext.INSTANCE : coroutineContext, (i2 & 4) != 0 ? -2 : i, (i2 & 8) != 0 ? BufferOverflow.SUSPEND : bufferOverflow);
+    }
+
+    public CallbackFlowBuilder(Function2 function2, CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow) {
+        super(function2, coroutineContext, i, bufferOverflow);
+        this.block = function2;
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:12:0x0049  */
+    /* JADX WARN: Removed duplicated region for block: B:15:0x004c  */
+    /* JADX WARN: Removed duplicated region for block: B:19:0x0035  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+    @Override // kotlinx.coroutines.flow.ChannelFlowBuilder, kotlinx.coroutines.flow.internal.ChannelFlow
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public java.lang.Object collectTo(kotlinx.coroutines.channels.ProducerScope r5, kotlin.coroutines.Continuation r6) {
+        /*
+            r4 = this;
+            boolean r0 = r6 instanceof kotlinx.coroutines.flow.CallbackFlowBuilder$collectTo$1
+            if (r0 == 0) goto L13
+            r0 = r6
+            kotlinx.coroutines.flow.CallbackFlowBuilder$collectTo$1 r0 = (kotlinx.coroutines.flow.CallbackFlowBuilder$collectTo$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.CallbackFlowBuilder$collectTo$1 r0 = new kotlinx.coroutines.flow.CallbackFlowBuilder$collectTo$1
+            r0.<init>(r4, r6)
+        L18:
+            java.lang.Object r6 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 1
+            if (r2 == 0) goto L35
+            if (r2 != r3) goto L2d
+            java.lang.Object r5 = r0.L$0
+            kotlinx.coroutines.channels.ProducerScope r5 = (kotlinx.coroutines.channels.ProducerScope) r5
+            kotlin.ResultKt.throwOnFailure(r6)
+            goto L43
+        L2d:
+            java.lang.IllegalStateException r5 = new java.lang.IllegalStateException
+            java.lang.String r6 = "call to 'resume' before 'invoke' with coroutine"
+            r5.<init>(r6)
+            throw r5
+        L35:
+            kotlin.ResultKt.throwOnFailure(r6)
+            r0.L$0 = r5
+            r0.label = r3
+            java.lang.Object r6 = super.collectTo(r5, r0)
+            if (r6 != r1) goto L43
+            return r1
+        L43:
+            boolean r5 = r5.isClosedForSend()
+            if (r5 == 0) goto L4c
+            kotlin.Unit r5 = kotlin.Unit.INSTANCE
+            return r5
+        L4c:
+            java.lang.IllegalStateException r5 = new java.lang.IllegalStateException
+            java.lang.String r6 = "'awaitClose { yourCallbackOrListener.cancel() }' should be used in the end of callbackFlow block.\nOtherwise, a callback/listener may leak in case of external cancellation.\nSee callbackFlow API documentation for the details."
+            r5.<init>(r6)
+            throw r5
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.CallbackFlowBuilder.collectTo(kotlinx.coroutines.channels.ProducerScope, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+
+    @Override // kotlinx.coroutines.flow.ChannelFlowBuilder, kotlinx.coroutines.flow.internal.ChannelFlow
+    public ChannelFlow create(CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow) {
+        return new CallbackFlowBuilder(this.block, coroutineContext, i, bufferOverflow);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/ChannelFlowBuilder.java

@@ -0,0 +1,48 @@
+package kotlinx.coroutines.flow;
+
+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.Function2;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlinx.coroutines.channels.BufferOverflow;
+import kotlinx.coroutines.channels.ProducerScope;
+import kotlinx.coroutines.flow.internal.ChannelFlow;
+
+/* loaded from: classes5.dex */
+public class ChannelFlowBuilder extends ChannelFlow {
+    public final Function2 block;
+
+    @Override // kotlinx.coroutines.flow.internal.ChannelFlow
+    public Object collectTo(ProducerScope producerScope, Continuation continuation) {
+        return collectTo$suspendImpl(this, producerScope, continuation);
+    }
+
+    public /* synthetic */ ChannelFlowBuilder(Function2 function2, CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow, int i2, DefaultConstructorMarker defaultConstructorMarker) {
+        this(function2, (i2 & 2) != 0 ? EmptyCoroutineContext.INSTANCE : coroutineContext, (i2 & 4) != 0 ? -2 : i, (i2 & 8) != 0 ? BufferOverflow.SUSPEND : bufferOverflow);
+    }
+
+    public ChannelFlowBuilder(Function2 function2, CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow) {
+        super(coroutineContext, i, bufferOverflow);
+        this.block = function2;
+    }
+
+    @Override // kotlinx.coroutines.flow.internal.ChannelFlow
+    public ChannelFlow create(CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow) {
+        return new ChannelFlowBuilder(this.block, coroutineContext, i, bufferOverflow);
+    }
+
+    public static /* synthetic */ Object collectTo$suspendImpl(ChannelFlowBuilder channelFlowBuilder, ProducerScope producerScope, Continuation continuation) {
+        Object coroutine_suspended;
+        Object invoke = channelFlowBuilder.block.invoke(producerScope, continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return invoke == coroutine_suspended ? invoke : Unit.INSTANCE;
+    }
+
+    @Override // kotlinx.coroutines.flow.internal.ChannelFlow
+    public String toString() {
+        return "block[" + this.block + "] -> " + super.toString();
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/DistinctFlowImpl$collect$2$emit$1.java

@@ -0,0 +1,24 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+
+/* loaded from: classes5.dex */
+public final class DistinctFlowImpl$collect$2$emit$1 extends ContinuationImpl {
+    public int label;
+    public /* synthetic */ Object result;
+    public final /* synthetic */ DistinctFlowImpl$collect$2 this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public DistinctFlowImpl$collect$2$emit$1(DistinctFlowImpl$collect$2 distinctFlowImpl$collect$2, Continuation continuation) {
+        super(continuation);
+        this.this$0 = distinctFlowImpl$collect$2;
+    }
+
+    @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/DistinctFlowImpl$collect$2.java

@@ -0,0 +1,90 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.jvm.internal.Ref;
+
+/* loaded from: classes5.dex */
+public final class DistinctFlowImpl$collect$2 implements FlowCollector {
+    public final /* synthetic */ FlowCollector $collector;
+    public final /* synthetic */ Ref.ObjectRef $previousKey;
+    public final /* synthetic */ DistinctFlowImpl this$0;
+
+    public DistinctFlowImpl$collect$2(DistinctFlowImpl distinctFlowImpl, Ref.ObjectRef objectRef, FlowCollector flowCollector) {
+        this.this$0 = distinctFlowImpl;
+        this.$previousKey = objectRef;
+        this.$collector = flowCollector;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Removed duplicated region for block: B:15:0x0031  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+    /* JADX WARN: Type inference failed for: r7v4, types: [T, java.lang.Object] */
+    @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 r6, kotlin.coroutines.Continuation r7) {
+        /*
+            r5 = this;
+            boolean r0 = r7 instanceof kotlinx.coroutines.flow.DistinctFlowImpl$collect$2$emit$1
+            if (r0 == 0) goto L13
+            r0 = r7
+            kotlinx.coroutines.flow.DistinctFlowImpl$collect$2$emit$1 r0 = (kotlinx.coroutines.flow.DistinctFlowImpl$collect$2$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.DistinctFlowImpl$collect$2$emit$1 r0 = new kotlinx.coroutines.flow.DistinctFlowImpl$collect$2$emit$1
+            r0.<init>(r5, r7)
+        L18:
+            java.lang.Object r7 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 1
+            if (r2 == 0) goto L31
+            if (r2 != r3) goto L29
+            kotlin.ResultKt.throwOnFailure(r7)
+            goto L67
+        L29:
+            java.lang.IllegalStateException r6 = new java.lang.IllegalStateException
+            java.lang.String r7 = "call to 'resume' before 'invoke' with coroutine"
+            r6.<init>(r7)
+            throw r6
+        L31:
+            kotlin.ResultKt.throwOnFailure(r7)
+            kotlinx.coroutines.flow.DistinctFlowImpl r7 = r5.this$0
+            kotlin.jvm.functions.Function1 r7 = r7.keySelector
+            java.lang.Object r7 = r7.invoke(r6)
+            kotlin.jvm.internal.Ref$ObjectRef r2 = r5.$previousKey
+            T r2 = r2.element
+            kotlinx.coroutines.internal.Symbol r4 = kotlinx.coroutines.flow.internal.NullSurrogateKt.NULL
+            if (r2 == r4) goto L58
+            kotlinx.coroutines.flow.DistinctFlowImpl r4 = r5.this$0
+            kotlin.jvm.functions.Function2 r4 = r4.areEquivalent
+            java.lang.Object r2 = r4.invoke(r2, r7)
+            java.lang.Boolean r2 = (java.lang.Boolean) r2
+            boolean r2 = r2.booleanValue()
+            if (r2 != 0) goto L55
+            goto L58
+        L55:
+            kotlin.Unit r6 = kotlin.Unit.INSTANCE
+            return r6
+        L58:
+            kotlin.jvm.internal.Ref$ObjectRef r2 = r5.$previousKey
+            r2.element = r7
+            kotlinx.coroutines.flow.FlowCollector r7 = r5.$collector
+            r0.label = r3
+            java.lang.Object r6 = r7.emit(r6, r0)
+            if (r6 != r1) goto L67
+            return r1
+        L67:
+            kotlin.Unit r6 = kotlin.Unit.INSTANCE
+            return r6
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.DistinctFlowImpl$collect$2.emit(java.lang.Object, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/DistinctFlowImpl.java

@@ -0,0 +1,33 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Ref;
+import kotlinx.coroutines.flow.internal.NullSurrogateKt;
+
+/* loaded from: classes5.dex */
+public final class DistinctFlowImpl implements Flow {
+    public final Function2 areEquivalent;
+    public final Function1 keySelector;
+    public final Flow upstream;
+
+    public DistinctFlowImpl(Flow flow, Function1 function1, Function2 function2) {
+        this.upstream = flow;
+        this.keySelector = function1;
+        this.areEquivalent = function2;
+    }
+
+    /* JADX WARN: Type inference failed for: r1v0, types: [T, kotlinx.coroutines.internal.Symbol] */
+    @Override // kotlinx.coroutines.flow.Flow
+    public Object collect(FlowCollector flowCollector, Continuation continuation) {
+        Object coroutine_suspended;
+        Ref.ObjectRef objectRef = new Ref.ObjectRef();
+        objectRef.element = NullSurrogateKt.NULL;
+        Object collect = this.upstream.collect(new DistinctFlowImpl$collect$2(this, objectRef, flowCollector), continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return collect == coroutine_suspended ? collect : Unit.INSTANCE;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/Flow.java

@@ -0,0 +1,8 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+
+/* loaded from: classes5.dex */
+public interface Flow {
+    Object collect(FlowCollector flowCollector, Continuation continuation);
+}

decompiled/sources/kotlinx/coroutines/flow/FlowCollector.java

@@ -0,0 +1,8 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+
+/* loaded from: classes5.dex */
+public interface FlowCollector {
+    Object emit(Object obj, Continuation continuation);
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt.java

@@ -0,0 +1,147 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.functions.Function3;
+import kotlin.jvm.functions.Function4;
+import kotlinx.coroutines.CoroutineScope;
+import kotlinx.coroutines.Job;
+import kotlinx.coroutines.channels.BufferOverflow;
+import kotlinx.coroutines.channels.ReceiveChannel;
+
+/* loaded from: classes5.dex */
+public abstract class FlowKt {
+    public static final SharedFlow asSharedFlow(MutableSharedFlow mutableSharedFlow) {
+        return FlowKt__ShareKt.asSharedFlow(mutableSharedFlow);
+    }
+
+    public static final StateFlow asStateFlow(MutableStateFlow mutableStateFlow) {
+        return FlowKt__ShareKt.asStateFlow(mutableStateFlow);
+    }
+
+    public static final Flow buffer(Flow flow, int i, BufferOverflow bufferOverflow) {
+        return FlowKt__ContextKt.buffer(flow, i, bufferOverflow);
+    }
+
+    public static final Flow callbackFlow(Function2 function2) {
+        return FlowKt__BuildersKt.callbackFlow(function2);
+    }
+
+    /* renamed from: catch, reason: not valid java name */
+    public static final Flow m4143catch(Flow flow, Function3 function3) {
+        return FlowKt__ErrorsKt.m4144catch(flow, function3);
+    }
+
+    public static final Object catchImpl(Flow flow, FlowCollector flowCollector, Continuation continuation) {
+        return FlowKt__ErrorsKt.catchImpl(flow, flowCollector, continuation);
+    }
+
+    public static final Flow channelFlow(Function2 function2) {
+        return FlowKt__BuildersKt.channelFlow(function2);
+    }
+
+    public static final Object collect(Flow flow, Continuation continuation) {
+        return FlowKt__CollectKt.collect(flow, continuation);
+    }
+
+    public static final Object collectLatest(Flow flow, Function2 function2, Continuation continuation) {
+        return FlowKt__CollectKt.collectLatest(flow, function2, continuation);
+    }
+
+    public static final Flow conflate(Flow flow) {
+        return FlowKt__ContextKt.conflate(flow);
+    }
+
+    public static final Flow distinctUntilChanged(Flow flow) {
+        return FlowKt__DistinctKt.distinctUntilChanged(flow);
+    }
+
+    public static final Flow dropWhile(Flow flow, Function2 function2) {
+        return FlowKt__LimitKt.dropWhile(flow, function2);
+    }
+
+    public static final Object emitAll(FlowCollector flowCollector, ReceiveChannel receiveChannel, Continuation continuation) {
+        return FlowKt__ChannelsKt.emitAll(flowCollector, receiveChannel, continuation);
+    }
+
+    public static final Object emitAll(FlowCollector flowCollector, Flow flow, Continuation continuation) {
+        return FlowKt__CollectKt.emitAll(flowCollector, flow, continuation);
+    }
+
+    public static final void ensureActive(FlowCollector flowCollector) {
+        FlowKt__EmittersKt.ensureActive(flowCollector);
+    }
+
+    public static final Object first(Flow flow, Continuation continuation) {
+        return FlowKt__ReduceKt.first(flow, continuation);
+    }
+
+    public static final Object first(Flow flow, Function2 function2, Continuation continuation) {
+        return FlowKt__ReduceKt.first(flow, function2, continuation);
+    }
+
+    public static final Flow flow(Function2 function2) {
+        return FlowKt__BuildersKt.flow(function2);
+    }
+
+    public static final Flow flowCombine(Flow flow, Flow flow2, Function3 function3) {
+        return FlowKt__ZipKt.flowCombine(flow, flow2, function3);
+    }
+
+    public static final Flow flowOf(Object obj) {
+        return FlowKt__BuildersKt.flowOf(obj);
+    }
+
+    public static final Flow flowOn(Flow flow, CoroutineContext coroutineContext) {
+        return FlowKt__ContextKt.flowOn(flow, coroutineContext);
+    }
+
+    public static final Job launchIn(Flow flow, CoroutineScope coroutineScope) {
+        return FlowKt__CollectKt.launchIn(flow, coroutineScope);
+    }
+
+    public static final Flow mapLatest(Flow flow, Function2 function2) {
+        return FlowKt__MergeKt.mapLatest(flow, function2);
+    }
+
+    public static final Flow onCompletion(Flow flow, Function3 function3) {
+        return FlowKt__EmittersKt.onCompletion(flow, function3);
+    }
+
+    public static final Flow onEach(Flow flow, Function2 function2) {
+        return FlowKt__TransformKt.onEach(flow, function2);
+    }
+
+    public static final Flow onStart(Flow flow, Function2 function2) {
+        return FlowKt__EmittersKt.onStart(flow, function2);
+    }
+
+    public static final SharedFlow onSubscription(SharedFlow sharedFlow, Function2 function2) {
+        return FlowKt__ShareKt.onSubscription(sharedFlow, function2);
+    }
+
+    public static final Flow retryWhen(Flow flow, Function4 function4) {
+        return FlowKt__ErrorsKt.retryWhen(flow, function4);
+    }
+
+    public static final SharedFlow shareIn(Flow flow, CoroutineScope coroutineScope, SharingStarted sharingStarted, int i) {
+        return FlowKt__ShareKt.shareIn(flow, coroutineScope, sharingStarted, i);
+    }
+
+    public static final Object single(Flow flow, Continuation continuation) {
+        return FlowKt__ReduceKt.single(flow, continuation);
+    }
+
+    public static final Flow take(Flow flow, int i) {
+        return FlowKt__LimitKt.take(flow, i);
+    }
+
+    public static final Flow transformLatest(Flow flow, Function3 function3) {
+        return FlowKt__MergeKt.transformLatest(flow, function3);
+    }
+
+    public static final Flow transformWhile(Flow flow, Function3 function3) {
+        return FlowKt__LimitKt.transformWhile(flow, function3);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__BuildersKt.java

@@ -0,0 +1,33 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.jvm.functions.Function2;
+
+/* loaded from: classes5.dex */
+public abstract /* synthetic */ class FlowKt__BuildersKt {
+    public static final Flow flow(Function2 function2) {
+        return new SafeFlow(function2);
+    }
+
+    public static final Flow flowOf(final Object obj) {
+        return new Flow() { // from class: kotlinx.coroutines.flow.FlowKt__BuildersKt$flowOf$$inlined$unsafeFlow$2
+            @Override // kotlinx.coroutines.flow.Flow
+            public Object collect(FlowCollector flowCollector, Continuation continuation) {
+                Object coroutine_suspended;
+                Object emit = flowCollector.emit(obj, continuation);
+                coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+                return emit == coroutine_suspended ? emit : Unit.INSTANCE;
+            }
+        };
+    }
+
+    public static final Flow channelFlow(Function2 function2) {
+        return new ChannelFlowBuilder(function2, null, 0, null, 14, null);
+    }
+
+    public static final Flow callbackFlow(Function2 function2) {
+        return new CallbackFlowBuilder(function2, null, 0, null, 14, null);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__ChannelsKt$emitAllImpl$1.java

@@ -0,0 +1,27 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__ChannelsKt$emitAllImpl$1 extends ContinuationImpl {
+    public Object L$0;
+    public Object L$1;
+    public Object L$2;
+    public boolean Z$0;
+    public int label;
+    public /* synthetic */ Object result;
+
+    public FlowKt__ChannelsKt$emitAllImpl$1(Continuation continuation) {
+        super(continuation);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object emitAllImpl$FlowKt__ChannelsKt;
+        this.result = obj;
+        this.label |= Integer.MIN_VALUE;
+        emitAllImpl$FlowKt__ChannelsKt = FlowKt__ChannelsKt.emitAllImpl$FlowKt__ChannelsKt(null, null, false, this);
+        return emitAllImpl$FlowKt__ChannelsKt;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__ChannelsKt.java

@@ -0,0 +1,132 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlinx.coroutines.channels.ReceiveChannel;
+
+/* loaded from: classes5.dex */
+public abstract /* synthetic */ class FlowKt__ChannelsKt {
+    public static final Object emitAll(FlowCollector flowCollector, ReceiveChannel receiveChannel, Continuation continuation) {
+        Object coroutine_suspended;
+        Object emitAllImpl$FlowKt__ChannelsKt = emitAllImpl$FlowKt__ChannelsKt(flowCollector, receiveChannel, true, continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return emitAllImpl$FlowKt__ChannelsKt == coroutine_suspended ? emitAllImpl$FlowKt__ChannelsKt : Unit.INSTANCE;
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:16:0x0072 A[RETURN] */
+    /* JADX WARN: Removed duplicated region for block: B:18:0x0073  */
+    /* JADX WARN: Removed duplicated region for block: B:21:0x007f A[Catch: all -> 0x003c, TRY_LEAVE, TryCatch #0 {all -> 0x003c, blocks: (B:12:0x0036, B:14:0x0062, B:19:0x0077, B:21:0x007f, B:32:0x0054, B:34:0x005e), top: B:7:0x0022 }] */
+    /* JADX WARN: Removed duplicated region for block: B:24:0x0094  */
+    /* JADX WARN: Removed duplicated region for block: B:33:0x0058  */
+    /* JADX WARN: Removed duplicated region for block: B:9:0x0024  */
+    /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:22:0x0091 -> B:13:0x0039). Please report as a decompilation issue!!! */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static final java.lang.Object emitAllImpl$FlowKt__ChannelsKt(kotlinx.coroutines.flow.FlowCollector r6, kotlinx.coroutines.channels.ReceiveChannel r7, boolean r8, kotlin.coroutines.Continuation r9) {
+        /*
+            boolean r0 = r9 instanceof kotlinx.coroutines.flow.FlowKt__ChannelsKt$emitAllImpl$1
+            if (r0 == 0) goto L13
+            r0 = r9
+            kotlinx.coroutines.flow.FlowKt__ChannelsKt$emitAllImpl$1 r0 = (kotlinx.coroutines.flow.FlowKt__ChannelsKt$emitAllImpl$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.FlowKt__ChannelsKt$emitAllImpl$1 r0 = new kotlinx.coroutines.flow.FlowKt__ChannelsKt$emitAllImpl$1
+            r0.<init>(r9)
+        L18:
+            java.lang.Object r9 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 2
+            r4 = 1
+            if (r2 == 0) goto L58
+            if (r2 == r4) goto L46
+            if (r2 != r3) goto L3e
+            boolean r8 = r0.Z$0
+            java.lang.Object r6 = r0.L$2
+            kotlinx.coroutines.channels.ChannelIterator r6 = (kotlinx.coroutines.channels.ChannelIterator) r6
+            java.lang.Object r7 = r0.L$1
+            kotlinx.coroutines.channels.ReceiveChannel r7 = (kotlinx.coroutines.channels.ReceiveChannel) r7
+            java.lang.Object r2 = r0.L$0
+            kotlinx.coroutines.flow.FlowCollector r2 = (kotlinx.coroutines.flow.FlowCollector) r2
+            kotlin.ResultKt.throwOnFailure(r9)     // Catch: java.lang.Throwable -> L3c
+        L39:
+            r9 = r6
+            r6 = r2
+            goto L62
+        L3c:
+            r6 = move-exception
+            goto L9d
+        L3e:
+            java.lang.IllegalStateException r6 = new java.lang.IllegalStateException
+            java.lang.String r7 = "call to 'resume' before 'invoke' with coroutine"
+            r6.<init>(r7)
+            throw r6
+        L46:
+            boolean r8 = r0.Z$0
+            java.lang.Object r6 = r0.L$2
+            kotlinx.coroutines.channels.ChannelIterator r6 = (kotlinx.coroutines.channels.ChannelIterator) r6
+            java.lang.Object r7 = r0.L$1
+            kotlinx.coroutines.channels.ReceiveChannel r7 = (kotlinx.coroutines.channels.ReceiveChannel) r7
+            java.lang.Object r2 = r0.L$0
+            kotlinx.coroutines.flow.FlowCollector r2 = (kotlinx.coroutines.flow.FlowCollector) r2
+            kotlin.ResultKt.throwOnFailure(r9)     // Catch: java.lang.Throwable -> L3c
+            goto L77
+        L58:
+            kotlin.ResultKt.throwOnFailure(r9)
+            kotlinx.coroutines.flow.FlowKt.ensureActive(r6)
+            kotlinx.coroutines.channels.ChannelIterator r9 = r7.iterator()     // Catch: java.lang.Throwable -> L3c
+        L62:
+            r0.L$0 = r6     // Catch: java.lang.Throwable -> L3c
+            r0.L$1 = r7     // Catch: java.lang.Throwable -> L3c
+            r0.L$2 = r9     // Catch: java.lang.Throwable -> L3c
+            r0.Z$0 = r8     // Catch: java.lang.Throwable -> L3c
+            r0.label = r4     // Catch: java.lang.Throwable -> L3c
+            java.lang.Object r2 = r9.hasNext(r0)     // Catch: java.lang.Throwable -> L3c
+            if (r2 != r1) goto L73
+            return r1
+        L73:
+            r5 = r2
+            r2 = r6
+            r6 = r9
+            r9 = r5
+        L77:
+            java.lang.Boolean r9 = (java.lang.Boolean) r9     // Catch: java.lang.Throwable -> L3c
+            boolean r9 = r9.booleanValue()     // Catch: java.lang.Throwable -> L3c
+            if (r9 == 0) goto L94
+            java.lang.Object r9 = r6.next()     // Catch: java.lang.Throwable -> L3c
+            r0.L$0 = r2     // Catch: java.lang.Throwable -> L3c
+            r0.L$1 = r7     // Catch: java.lang.Throwable -> L3c
+            r0.L$2 = r6     // Catch: java.lang.Throwable -> L3c
+            r0.Z$0 = r8     // Catch: java.lang.Throwable -> L3c
+            r0.label = r3     // Catch: java.lang.Throwable -> L3c
+            java.lang.Object r9 = r2.emit(r9, r0)     // Catch: java.lang.Throwable -> L3c
+            if (r9 != r1) goto L39
+            return r1
+        L94:
+            if (r8 == 0) goto L9a
+            r6 = 0
+            kotlinx.coroutines.channels.ChannelsKt.cancelConsumed(r7, r6)
+        L9a:
+            kotlin.Unit r6 = kotlin.Unit.INSTANCE
+            return r6
+        L9d:
+            throw r6     // Catch: java.lang.Throwable -> L9e
+        L9e:
+            r9 = move-exception
+            if (r8 == 0) goto La4
+            kotlinx.coroutines.channels.ChannelsKt.cancelConsumed(r7, r6)
+        La4:
+            throw r9
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__ChannelsKt.emitAllImpl$FlowKt__ChannelsKt(kotlinx.coroutines.flow.FlowCollector, kotlinx.coroutines.channels.ReceiveChannel, boolean, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__CollectKt$launchIn$1.java

@@ -0,0 +1,52 @@
+package kotlinx.coroutines.flow;
+
+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;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__CollectKt$launchIn$1 extends SuspendLambda implements Function2 {
+    public final /* synthetic */ Flow $this_launchIn;
+    public int label;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public FlowKt__CollectKt$launchIn$1(Flow flow, Continuation continuation) {
+        super(2, continuation);
+        this.$this_launchIn = flow;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new FlowKt__CollectKt$launchIn$1(this.$this_launchIn, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(CoroutineScope coroutineScope, Continuation continuation) {
+        return ((FlowKt__CollectKt$launchIn$1) 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);
+            Flow flow = this.$this_launchIn;
+            this.label = 1;
+            if (FlowKt.collect(flow, 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/FlowKt__CollectKt.java

@@ -0,0 +1,41 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.BuildersKt__Builders_commonKt;
+import kotlinx.coroutines.CoroutineScope;
+import kotlinx.coroutines.Job;
+import kotlinx.coroutines.flow.internal.NopCollector;
+
+/* loaded from: classes5.dex */
+public abstract /* synthetic */ class FlowKt__CollectKt {
+    public static final Object collect(Flow flow, Continuation continuation) {
+        Object coroutine_suspended;
+        Object collect = flow.collect(NopCollector.INSTANCE, continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return collect == coroutine_suspended ? collect : Unit.INSTANCE;
+    }
+
+    public static final Job launchIn(Flow flow, CoroutineScope coroutineScope) {
+        Job launch$default;
+        launch$default = BuildersKt__Builders_commonKt.launch$default(coroutineScope, null, null, new FlowKt__CollectKt$launchIn$1(flow, null), 3, null);
+        return launch$default;
+    }
+
+    public static final Object collectLatest(Flow flow, Function2 function2, Continuation continuation) {
+        Object coroutine_suspended;
+        Object collect = FlowKt.collect(FlowKt__ContextKt.buffer$default(FlowKt.mapLatest(flow, function2), 0, null, 2, null), continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return collect == coroutine_suspended ? collect : Unit.INSTANCE;
+    }
+
+    public static final Object emitAll(FlowCollector flowCollector, Flow flow, Continuation continuation) {
+        Object coroutine_suspended;
+        FlowKt.ensureActive(flowCollector);
+        Object collect = flow.collect(flowCollector, continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return collect == coroutine_suspended ? collect : Unit.INSTANCE;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__ContextKt.java

@@ -0,0 +1,54 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.CoroutineContext;
+import kotlin.coroutines.EmptyCoroutineContext;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.Job;
+import kotlinx.coroutines.channels.BufferOverflow;
+import kotlinx.coroutines.flow.internal.ChannelFlowOperatorImpl;
+import kotlinx.coroutines.flow.internal.FusibleFlow;
+
+/* loaded from: classes5.dex */
+public abstract /* synthetic */ class FlowKt__ContextKt {
+    public static /* synthetic */ Flow buffer$default(Flow flow, int i, BufferOverflow bufferOverflow, int i2, Object obj) {
+        if ((i2 & 1) != 0) {
+            i = -2;
+        }
+        if ((i2 & 2) != 0) {
+            bufferOverflow = BufferOverflow.SUSPEND;
+        }
+        return FlowKt.buffer(flow, i, bufferOverflow);
+    }
+
+    public static final Flow buffer(Flow flow, int i, BufferOverflow bufferOverflow) {
+        if (i < 0 && i != -2 && i != -1) {
+            throw new IllegalArgumentException(("Buffer size should be non-negative, BUFFERED, or CONFLATED, but was " + i).toString());
+        }
+        if (i == -1 && bufferOverflow != BufferOverflow.SUSPEND) {
+            throw new IllegalArgumentException("CONFLATED capacity cannot be used with non-default onBufferOverflow".toString());
+        }
+        if (i == -1) {
+            bufferOverflow = BufferOverflow.DROP_OLDEST;
+            i = 0;
+        }
+        int i2 = i;
+        BufferOverflow bufferOverflow2 = bufferOverflow;
+        return flow instanceof FusibleFlow ? FusibleFlow.DefaultImpls.fuse$default((FusibleFlow) flow, null, i2, bufferOverflow2, 1, null) : new ChannelFlowOperatorImpl(flow, null, i2, bufferOverflow2, 2, null);
+    }
+
+    public static final Flow conflate(Flow flow) {
+        return buffer$default(flow, -1, null, 2, null);
+    }
+
+    public static final Flow flowOn(Flow flow, CoroutineContext coroutineContext) {
+        checkFlowContext$FlowKt__ContextKt(coroutineContext);
+        return Intrinsics.areEqual(coroutineContext, EmptyCoroutineContext.INSTANCE) ? flow : flow instanceof FusibleFlow ? FusibleFlow.DefaultImpls.fuse$default((FusibleFlow) flow, coroutineContext, 0, null, 6, null) : new ChannelFlowOperatorImpl(flow, coroutineContext, 0, null, 12, null);
+    }
+
+    public static final void checkFlowContext$FlowKt__ContextKt(CoroutineContext coroutineContext) {
+        if (coroutineContext.get(Job.Key) == null) {
+            return;
+        }
+        throw new IllegalArgumentException(("Flow context cannot contain job in it. Had " + coroutineContext).toString());
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__DistinctKt.java

@@ -0,0 +1,35 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract /* synthetic */ class FlowKt__DistinctKt {
+    public static final Function1 defaultKeySelector = new Function1() { // from class: kotlinx.coroutines.flow.FlowKt__DistinctKt$defaultKeySelector$1
+        @Override // kotlin.jvm.functions.Function1
+        public final Object invoke(Object obj) {
+            return obj;
+        }
+    };
+    public static final Function2 defaultAreEquivalent = new Function2() { // from class: kotlinx.coroutines.flow.FlowKt__DistinctKt$defaultAreEquivalent$1
+        @Override // kotlin.jvm.functions.Function2
+        public final Boolean invoke(Object obj, Object obj2) {
+            return Boolean.valueOf(Intrinsics.areEqual(obj, obj2));
+        }
+    };
+
+    public static final Flow distinctUntilChanged(Flow flow) {
+        return flow instanceof StateFlow ? flow : distinctUntilChangedBy$FlowKt__DistinctKt(flow, defaultKeySelector, defaultAreEquivalent);
+    }
+
+    public static final Flow distinctUntilChangedBy$FlowKt__DistinctKt(Flow flow, Function1 function1, Function2 function2) {
+        if (flow instanceof DistinctFlowImpl) {
+            DistinctFlowImpl distinctFlowImpl = (DistinctFlowImpl) flow;
+            if (distinctFlowImpl.keySelector == function1 && distinctFlowImpl.areEquivalent == function2) {
+                return flow;
+            }
+        }
+        return new DistinctFlowImpl(flow, function1, function2);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__EmittersKt$invokeSafely$1.java

@@ -0,0 +1,24 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__EmittersKt$invokeSafely$1 extends ContinuationImpl {
+    public Object L$0;
+    public int label;
+    public /* synthetic */ Object result;
+
+    public FlowKt__EmittersKt$invokeSafely$1(Continuation continuation) {
+        super(continuation);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object invokeSafely$FlowKt__EmittersKt;
+        this.result = obj;
+        this.label |= Integer.MIN_VALUE;
+        invokeSafely$FlowKt__EmittersKt = FlowKt__EmittersKt.invokeSafely$FlowKt__EmittersKt(null, null, null, this);
+        return invokeSafely$FlowKt__EmittersKt;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__EmittersKt$onCompletion$$inlined$unsafeFlow$1.java

@@ -0,0 +1,161 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.jvm.functions.Function3;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__EmittersKt$onCompletion$$inlined$unsafeFlow$1 implements Flow {
+    public final /* synthetic */ Function3 $action$inlined;
+    public final /* synthetic */ Flow $this_onCompletion$inlined;
+
+    /* renamed from: kotlinx.coroutines.flow.FlowKt__EmittersKt$onCompletion$$inlined$unsafeFlow$1$1, reason: invalid class name */
+    public static final class AnonymousClass1 extends ContinuationImpl {
+        public Object L$0;
+        public Object L$1;
+        public int label;
+        public /* synthetic */ Object result;
+
+        public AnonymousClass1(Continuation continuation) {
+            super(continuation);
+        }
+
+        @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+        public final Object invokeSuspend(Object obj) {
+            this.result = obj;
+            this.label |= Integer.MIN_VALUE;
+            return FlowKt__EmittersKt$onCompletion$$inlined$unsafeFlow$1.this.collect(null, this);
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:32:0x0086 A[RETURN] */
+    /* JADX WARN: Removed duplicated region for block: B:33:0x0087  */
+    /* JADX WARN: Removed duplicated region for block: B:41:0x00ab A[RETURN] */
+    /* JADX WARN: Removed duplicated region for block: B:42:? A[RETURN, SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:43:0x0054  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0026  */
+    @Override // kotlinx.coroutines.flow.Flow
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public java.lang.Object collect(kotlinx.coroutines.flow.FlowCollector r9, kotlin.coroutines.Continuation r10) {
+        /*
+            r8 = this;
+            boolean r0 = r10 instanceof kotlinx.coroutines.flow.FlowKt__EmittersKt$onCompletion$$inlined$unsafeFlow$1.AnonymousClass1
+            if (r0 == 0) goto L13
+            r0 = r10
+            kotlinx.coroutines.flow.FlowKt__EmittersKt$onCompletion$$inlined$unsafeFlow$1$1 r0 = (kotlinx.coroutines.flow.FlowKt__EmittersKt$onCompletion$$inlined$unsafeFlow$1.AnonymousClass1) 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.FlowKt__EmittersKt$onCompletion$$inlined$unsafeFlow$1$1 r0 = new kotlinx.coroutines.flow.FlowKt__EmittersKt$onCompletion$$inlined$unsafeFlow$1$1
+            r0.<init>(r10)
+        L18:
+            java.lang.Object r10 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 3
+            r4 = 2
+            r5 = 1
+            r6 = 0
+            if (r2 == 0) goto L54
+            if (r2 == r5) goto L46
+            if (r2 == r4) goto L3e
+            if (r2 != r3) goto L36
+            java.lang.Object r9 = r0.L$0
+            kotlinx.coroutines.flow.internal.SafeCollector r9 = (kotlinx.coroutines.flow.internal.SafeCollector) r9
+            kotlin.ResultKt.throwOnFailure(r10)     // Catch: java.lang.Throwable -> L34
+            goto L88
+        L34:
+            r10 = move-exception
+            goto L92
+        L36:
+            java.lang.IllegalStateException r9 = new java.lang.IllegalStateException
+            java.lang.String r10 = "call to 'resume' before 'invoke' with coroutine"
+            r9.<init>(r10)
+            throw r9
+        L3e:
+            java.lang.Object r9 = r0.L$0
+            java.lang.Throwable r9 = (java.lang.Throwable) r9
+            kotlin.ResultKt.throwOnFailure(r10)
+            goto Lac
+        L46:
+            java.lang.Object r9 = r0.L$1
+            kotlinx.coroutines.flow.FlowCollector r9 = (kotlinx.coroutines.flow.FlowCollector) r9
+            java.lang.Object r2 = r0.L$0
+            kotlinx.coroutines.flow.FlowKt__EmittersKt$onCompletion$$inlined$unsafeFlow$1 r2 = (kotlinx.coroutines.flow.FlowKt__EmittersKt$onCompletion$$inlined$unsafeFlow$1) r2
+            kotlin.ResultKt.throwOnFailure(r10)     // Catch: java.lang.Throwable -> L52
+            goto L67
+        L52:
+            r9 = move-exception
+            goto L98
+        L54:
+            kotlin.ResultKt.throwOnFailure(r10)
+            kotlinx.coroutines.flow.Flow r10 = r8.$this_onCompletion$inlined     // Catch: java.lang.Throwable -> L96
+            r0.L$0 = r8     // Catch: java.lang.Throwable -> L96
+            r0.L$1 = r9     // Catch: java.lang.Throwable -> L96
+            r0.label = r5     // Catch: java.lang.Throwable -> L96
+            java.lang.Object r10 = r10.collect(r9, r0)     // Catch: java.lang.Throwable -> L96
+            if (r10 != r1) goto L66
+            return r1
+        L66:
+            r2 = r8
+        L67:
+            kotlinx.coroutines.flow.internal.SafeCollector r10 = new kotlinx.coroutines.flow.internal.SafeCollector
+            kotlin.coroutines.CoroutineContext r4 = r0.getContext()
+            r10.<init>(r9, r4)
+            kotlin.jvm.functions.Function3 r9 = r2.$action$inlined     // Catch: java.lang.Throwable -> L8e
+            r0.L$0 = r10     // Catch: java.lang.Throwable -> L8e
+            r0.L$1 = r6     // Catch: java.lang.Throwable -> L8e
+            r0.label = r3     // Catch: java.lang.Throwable -> L8e
+            r2 = 6
+            kotlin.jvm.internal.InlineMarker.mark(r2)     // Catch: java.lang.Throwable -> L8e
+            java.lang.Object r9 = r9.invoke(r10, r6, r0)     // Catch: java.lang.Throwable -> L8e
+            r0 = 7
+            kotlin.jvm.internal.InlineMarker.mark(r0)     // Catch: java.lang.Throwable -> L8e
+            if (r9 != r1) goto L87
+            return r1
+        L87:
+            r9 = r10
+        L88:
+            r9.releaseIntercepted()
+            kotlin.Unit r9 = kotlin.Unit.INSTANCE
+            return r9
+        L8e:
+            r9 = move-exception
+            r7 = r10
+            r10 = r9
+            r9 = r7
+        L92:
+            r9.releaseIntercepted()
+            throw r10
+        L96:
+            r9 = move-exception
+            r2 = r8
+        L98:
+            kotlinx.coroutines.flow.ThrowingCollector r10 = new kotlinx.coroutines.flow.ThrowingCollector
+            r10.<init>(r9)
+            kotlin.jvm.functions.Function3 r2 = r2.$action$inlined
+            r0.L$0 = r9
+            r0.L$1 = r6
+            r0.label = r4
+            java.lang.Object r10 = kotlinx.coroutines.flow.FlowKt__EmittersKt.access$invokeSafely$FlowKt__EmittersKt(r10, r2, r9, r0)
+            if (r10 != r1) goto Lac
+            return r1
+        Lac:
+            throw r9
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__EmittersKt$onCompletion$$inlined$unsafeFlow$1.collect(kotlinx.coroutines.flow.FlowCollector, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+
+    public FlowKt__EmittersKt$onCompletion$$inlined$unsafeFlow$1(Flow flow, Function3 function3) {
+        this.$this_onCompletion$inlined = flow;
+        this.$action$inlined = function3;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__EmittersKt$onStart$$inlined$unsafeFlow$1.java

@@ -0,0 +1,136 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.jvm.functions.Function2;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__EmittersKt$onStart$$inlined$unsafeFlow$1 implements Flow {
+    public final /* synthetic */ Function2 $action$inlined;
+    public final /* synthetic */ Flow $this_onStart$inlined;
+
+    /* renamed from: kotlinx.coroutines.flow.FlowKt__EmittersKt$onStart$$inlined$unsafeFlow$1$1, reason: invalid class name */
+    public static final class AnonymousClass1 extends ContinuationImpl {
+        public Object L$0;
+        public Object L$1;
+        public Object L$2;
+        public int label;
+        public /* synthetic */ Object result;
+
+        public AnonymousClass1(Continuation continuation) {
+            super(continuation);
+        }
+
+        @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+        public final Object invokeSuspend(Object obj) {
+            this.result = obj;
+            this.label |= Integer.MIN_VALUE;
+            return FlowKt__EmittersKt$onStart$$inlined$unsafeFlow$1.this.collect(null, this);
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:21:0x0082 A[RETURN] */
+    /* JADX WARN: Removed duplicated region for block: B:26:0x0046  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0024  */
+    @Override // kotlinx.coroutines.flow.Flow
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public java.lang.Object collect(kotlinx.coroutines.flow.FlowCollector r7, kotlin.coroutines.Continuation r8) {
+        /*
+            r6 = this;
+            boolean r0 = r8 instanceof kotlinx.coroutines.flow.FlowKt__EmittersKt$onStart$$inlined$unsafeFlow$1.AnonymousClass1
+            if (r0 == 0) goto L13
+            r0 = r8
+            kotlinx.coroutines.flow.FlowKt__EmittersKt$onStart$$inlined$unsafeFlow$1$1 r0 = (kotlinx.coroutines.flow.FlowKt__EmittersKt$onStart$$inlined$unsafeFlow$1.AnonymousClass1) 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.FlowKt__EmittersKt$onStart$$inlined$unsafeFlow$1$1 r0 = new kotlinx.coroutines.flow.FlowKt__EmittersKt$onStart$$inlined$unsafeFlow$1$1
+            r0.<init>(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 L46
+            if (r2 == r4) goto L34
+            if (r2 != r3) goto L2c
+            kotlin.ResultKt.throwOnFailure(r8)
+            goto L83
+        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:
+            java.lang.Object r7 = r0.L$2
+            kotlinx.coroutines.flow.internal.SafeCollector r7 = (kotlinx.coroutines.flow.internal.SafeCollector) r7
+            java.lang.Object r2 = r0.L$1
+            kotlinx.coroutines.flow.FlowCollector r2 = (kotlinx.coroutines.flow.FlowCollector) r2
+            java.lang.Object r4 = r0.L$0
+            kotlinx.coroutines.flow.FlowKt__EmittersKt$onStart$$inlined$unsafeFlow$1 r4 = (kotlinx.coroutines.flow.FlowKt__EmittersKt$onStart$$inlined$unsafeFlow$1) r4
+            kotlin.ResultKt.throwOnFailure(r8)     // Catch: java.lang.Throwable -> L44
+            goto L6e
+        L44:
+            r8 = move-exception
+            goto L8a
+        L46:
+            kotlin.ResultKt.throwOnFailure(r8)
+            kotlinx.coroutines.flow.internal.SafeCollector r8 = new kotlinx.coroutines.flow.internal.SafeCollector
+            kotlin.coroutines.CoroutineContext r2 = r0.getContext()
+            r8.<init>(r7, r2)
+            kotlin.jvm.functions.Function2 r2 = r6.$action$inlined     // Catch: java.lang.Throwable -> L86
+            r0.L$0 = r6     // Catch: java.lang.Throwable -> L86
+            r0.L$1 = r7     // Catch: java.lang.Throwable -> L86
+            r0.L$2 = r8     // Catch: java.lang.Throwable -> L86
+            r0.label = r4     // Catch: java.lang.Throwable -> L86
+            r4 = 6
+            kotlin.jvm.internal.InlineMarker.mark(r4)     // Catch: java.lang.Throwable -> L86
+            java.lang.Object r2 = r2.invoke(r8, r0)     // Catch: java.lang.Throwable -> L86
+            r4 = 7
+            kotlin.jvm.internal.InlineMarker.mark(r4)     // Catch: java.lang.Throwable -> L86
+            if (r2 != r1) goto L6b
+            return r1
+        L6b:
+            r4 = r6
+            r2 = r7
+            r7 = r8
+        L6e:
+            r7.releaseIntercepted()
+            kotlinx.coroutines.flow.Flow r7 = r4.$this_onStart$inlined
+            r8 = 0
+            r0.L$0 = r8
+            r0.L$1 = r8
+            r0.L$2 = r8
+            r0.label = r3
+            java.lang.Object r7 = r7.collect(r2, r0)
+            if (r7 != r1) goto L83
+            return r1
+        L83:
+            kotlin.Unit r7 = kotlin.Unit.INSTANCE
+            return r7
+        L86:
+            r7 = move-exception
+            r5 = r8
+            r8 = r7
+            r7 = r5
+        L8a:
+            r7.releaseIntercepted()
+            throw r8
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__EmittersKt$onStart$$inlined$unsafeFlow$1.collect(kotlinx.coroutines.flow.FlowCollector, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+
+    public FlowKt__EmittersKt$onStart$$inlined$unsafeFlow$1(Function2 function2, Flow flow) {
+        this.$action$inlined = function2;
+        this.$this_onStart$inlined = flow;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__EmittersKt.java

@@ -0,0 +1,83 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.functions.Function3;
+
+/* loaded from: classes5.dex */
+public abstract /* synthetic */ class FlowKt__EmittersKt {
+    public static final Flow onCompletion(Flow flow, Function3 function3) {
+        return new FlowKt__EmittersKt$onCompletion$$inlined$unsafeFlow$1(flow, function3);
+    }
+
+    public static final Flow onStart(Flow flow, Function2 function2) {
+        return new FlowKt__EmittersKt$onStart$$inlined$unsafeFlow$1(function2, flow);
+    }
+
+    public static final void ensureActive(FlowCollector flowCollector) {
+        if (flowCollector instanceof ThrowingCollector) {
+            throw ((ThrowingCollector) flowCollector).e;
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:18:0x0038  */
+    /* JADX WARN: Removed duplicated region for block: B:9:0x0023  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static final java.lang.Object invokeSafely$FlowKt__EmittersKt(kotlinx.coroutines.flow.FlowCollector r4, kotlin.jvm.functions.Function3 r5, java.lang.Throwable r6, kotlin.coroutines.Continuation r7) {
+        /*
+            boolean r0 = r7 instanceof kotlinx.coroutines.flow.FlowKt__EmittersKt$invokeSafely$1
+            if (r0 == 0) goto L13
+            r0 = r7
+            kotlinx.coroutines.flow.FlowKt__EmittersKt$invokeSafely$1 r0 = (kotlinx.coroutines.flow.FlowKt__EmittersKt$invokeSafely$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.FlowKt__EmittersKt$invokeSafely$1 r0 = new kotlinx.coroutines.flow.FlowKt__EmittersKt$invokeSafely$1
+            r0.<init>(r7)
+        L18:
+            java.lang.Object r7 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 1
+            if (r2 == 0) goto L38
+            if (r2 != r3) goto L30
+            java.lang.Object r4 = r0.L$0
+            r6 = r4
+            java.lang.Throwable r6 = (java.lang.Throwable) r6
+            kotlin.ResultKt.throwOnFailure(r7)     // Catch: java.lang.Throwable -> L2e
+            goto L46
+        L2e:
+            r4 = move-exception
+            goto L49
+        L30:
+            java.lang.IllegalStateException r4 = new java.lang.IllegalStateException
+            java.lang.String r5 = "call to 'resume' before 'invoke' with coroutine"
+            r4.<init>(r5)
+            throw r4
+        L38:
+            kotlin.ResultKt.throwOnFailure(r7)
+            r0.L$0 = r6     // Catch: java.lang.Throwable -> L2e
+            r0.label = r3     // Catch: java.lang.Throwable -> L2e
+            java.lang.Object r4 = r5.invoke(r4, r6, r0)     // Catch: java.lang.Throwable -> L2e
+            if (r4 != r1) goto L46
+            return r1
+        L46:
+            kotlin.Unit r4 = kotlin.Unit.INSTANCE
+            return r4
+        L49:
+            if (r6 == 0) goto L50
+            if (r6 == r4) goto L50
+            kotlin.ExceptionsKt.addSuppressed(r4, r6)
+        L50:
+            throw r4
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__EmittersKt.invokeSafely$FlowKt__EmittersKt(kotlinx.coroutines.flow.FlowCollector, kotlin.jvm.functions.Function3, java.lang.Throwable, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__ErrorsKt$catch$$inlined$unsafeFlow$1.java

@@ -0,0 +1,116 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.jvm.functions.Function3;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__ErrorsKt$catch$$inlined$unsafeFlow$1 implements Flow {
+    public final /* synthetic */ Function3 $action$inlined;
+    public final /* synthetic */ Flow $this_catch$inlined;
+
+    /* renamed from: kotlinx.coroutines.flow.FlowKt__ErrorsKt$catch$$inlined$unsafeFlow$1$1, reason: invalid class name */
+    public static final class AnonymousClass1 extends ContinuationImpl {
+        public Object L$0;
+        public Object L$1;
+        public int label;
+        public /* synthetic */ Object result;
+
+        public AnonymousClass1(Continuation continuation) {
+            super(continuation);
+        }
+
+        @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+        public final Object invokeSuspend(Object obj) {
+            this.result = obj;
+            this.label |= Integer.MIN_VALUE;
+            return FlowKt__ErrorsKt$catch$$inlined$unsafeFlow$1.this.collect(null, this);
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:19:0x0057  */
+    /* JADX WARN: Removed duplicated region for block: B:22:0x0040  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0024  */
+    @Override // kotlinx.coroutines.flow.Flow
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public java.lang.Object collect(kotlinx.coroutines.flow.FlowCollector r6, kotlin.coroutines.Continuation r7) {
+        /*
+            r5 = this;
+            boolean r0 = r7 instanceof kotlinx.coroutines.flow.FlowKt__ErrorsKt$catch$$inlined$unsafeFlow$1.AnonymousClass1
+            if (r0 == 0) goto L13
+            r0 = r7
+            kotlinx.coroutines.flow.FlowKt__ErrorsKt$catch$$inlined$unsafeFlow$1$1 r0 = (kotlinx.coroutines.flow.FlowKt__ErrorsKt$catch$$inlined$unsafeFlow$1.AnonymousClass1) 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.FlowKt__ErrorsKt$catch$$inlined$unsafeFlow$1$1 r0 = new kotlinx.coroutines.flow.FlowKt__ErrorsKt$catch$$inlined$unsafeFlow$1$1
+            r0.<init>(r7)
+        L18:
+            java.lang.Object r7 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 2
+            r4 = 1
+            if (r2 == 0) goto L40
+            if (r2 == r4) goto L34
+            if (r2 != r3) goto L2c
+            kotlin.ResultKt.throwOnFailure(r7)
+            goto L6f
+        L2c:
+            java.lang.IllegalStateException r6 = new java.lang.IllegalStateException
+            java.lang.String r7 = "call to 'resume' before 'invoke' with coroutine"
+            r6.<init>(r7)
+            throw r6
+        L34:
+            java.lang.Object r6 = r0.L$1
+            kotlinx.coroutines.flow.FlowCollector r6 = (kotlinx.coroutines.flow.FlowCollector) r6
+            java.lang.Object r2 = r0.L$0
+            kotlinx.coroutines.flow.FlowKt__ErrorsKt$catch$$inlined$unsafeFlow$1 r2 = (kotlinx.coroutines.flow.FlowKt__ErrorsKt$catch$$inlined$unsafeFlow$1) r2
+            kotlin.ResultKt.throwOnFailure(r7)
+            goto L53
+        L40:
+            kotlin.ResultKt.throwOnFailure(r7)
+            kotlinx.coroutines.flow.Flow r7 = r5.$this_catch$inlined
+            r0.L$0 = r5
+            r0.L$1 = r6
+            r0.label = r4
+            java.lang.Object r7 = kotlinx.coroutines.flow.FlowKt.catchImpl(r7, r6, r0)
+            if (r7 != r1) goto L52
+            return r1
+        L52:
+            r2 = r5
+        L53:
+            java.lang.Throwable r7 = (java.lang.Throwable) r7
+            if (r7 == 0) goto L6f
+            kotlin.jvm.functions.Function3 r2 = r2.$action$inlined
+            r4 = 0
+            r0.L$0 = r4
+            r0.L$1 = r4
+            r0.label = r3
+            r3 = 6
+            kotlin.jvm.internal.InlineMarker.mark(r3)
+            java.lang.Object r6 = r2.invoke(r6, r7, r0)
+            r7 = 7
+            kotlin.jvm.internal.InlineMarker.mark(r7)
+            if (r6 != r1) goto L6f
+            return r1
+        L6f:
+            kotlin.Unit r6 = kotlin.Unit.INSTANCE
+            return r6
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__ErrorsKt$catch$$inlined$unsafeFlow$1.collect(kotlinx.coroutines.flow.FlowCollector, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+
+    public FlowKt__ErrorsKt$catch$$inlined$unsafeFlow$1(Flow flow, Function3 function3) {
+        this.$this_catch$inlined = flow;
+        this.$action$inlined = function3;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__ErrorsKt$catchImpl$1.java

@@ -0,0 +1,22 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__ErrorsKt$catchImpl$1 extends ContinuationImpl {
+    public Object L$0;
+    public int label;
+    public /* synthetic */ Object result;
+
+    public FlowKt__ErrorsKt$catchImpl$1(Continuation continuation) {
+        super(continuation);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        this.result = obj;
+        this.label |= Integer.MIN_VALUE;
+        return FlowKt.catchImpl(null, null, this);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__ErrorsKt$catchImpl$2$emit$1.java

@@ -0,0 +1,25 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__ErrorsKt$catchImpl$2$emit$1 extends ContinuationImpl {
+    public Object L$0;
+    public int label;
+    public /* synthetic */ Object result;
+    public final /* synthetic */ FlowKt__ErrorsKt$catchImpl$2 this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public FlowKt__ErrorsKt$catchImpl$2$emit$1(FlowKt__ErrorsKt$catchImpl$2 flowKt__ErrorsKt$catchImpl$2, Continuation continuation) {
+        super(continuation);
+        this.this$0 = flowKt__ErrorsKt$catchImpl$2;
+    }
+
+    @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/FlowKt__ErrorsKt$catchImpl$2.java

@@ -0,0 +1,82 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.jvm.internal.Ref;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__ErrorsKt$catchImpl$2 implements FlowCollector {
+    public final /* synthetic */ FlowCollector $collector;
+    public final /* synthetic */ Ref.ObjectRef $fromDownstream;
+
+    public FlowKt__ErrorsKt$catchImpl$2(FlowCollector flowCollector, Ref.ObjectRef objectRef) {
+        this.$collector = flowCollector;
+        this.$fromDownstream = objectRef;
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:21:0x0037  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+    /* JADX WARN: Type inference failed for: r6v2, types: [java.lang.Throwable] */
+    /* JADX WARN: Type inference failed for: r6v4, types: [T, java.lang.Throwable] */
+    /* JADX WARN: Type inference failed for: r6v6, types: [java.lang.Throwable] */
+    @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 r5, kotlin.coroutines.Continuation r6) {
+        /*
+            r4 = this;
+            boolean r0 = r6 instanceof kotlinx.coroutines.flow.FlowKt__ErrorsKt$catchImpl$2$emit$1
+            if (r0 == 0) goto L13
+            r0 = r6
+            kotlinx.coroutines.flow.FlowKt__ErrorsKt$catchImpl$2$emit$1 r0 = (kotlinx.coroutines.flow.FlowKt__ErrorsKt$catchImpl$2$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.FlowKt__ErrorsKt$catchImpl$2$emit$1 r0 = new kotlinx.coroutines.flow.FlowKt__ErrorsKt$catchImpl$2$emit$1
+            r0.<init>(r4, r6)
+        L18:
+            java.lang.Object r6 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 1
+            if (r2 == 0) goto L37
+            if (r2 != r3) goto L2f
+            java.lang.Object r5 = r0.L$0
+            kotlinx.coroutines.flow.FlowKt__ErrorsKt$catchImpl$2 r5 = (kotlinx.coroutines.flow.FlowKt__ErrorsKt$catchImpl$2) r5
+            kotlin.ResultKt.throwOnFailure(r6)     // Catch: java.lang.Throwable -> L2d
+            goto L47
+        L2d:
+            r6 = move-exception
+            goto L4c
+        L2f:
+            java.lang.IllegalStateException r5 = new java.lang.IllegalStateException
+            java.lang.String r6 = "call to 'resume' before 'invoke' with coroutine"
+            r5.<init>(r6)
+            throw r5
+        L37:
+            kotlin.ResultKt.throwOnFailure(r6)
+            kotlinx.coroutines.flow.FlowCollector r6 = r4.$collector     // Catch: java.lang.Throwable -> L4a
+            r0.L$0 = r4     // Catch: java.lang.Throwable -> L4a
+            r0.label = r3     // Catch: java.lang.Throwable -> L4a
+            java.lang.Object r5 = r6.emit(r5, r0)     // Catch: java.lang.Throwable -> L4a
+            if (r5 != r1) goto L47
+            return r1
+        L47:
+            kotlin.Unit r5 = kotlin.Unit.INSTANCE
+            return r5
+        L4a:
+            r6 = move-exception
+            r5 = r4
+        L4c:
+            kotlin.jvm.internal.Ref$ObjectRef r5 = r5.$fromDownstream
+            r5.element = r6
+            throw r6
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__ErrorsKt$catchImpl$2.emit(java.lang.Object, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__ErrorsKt$retryWhen$$inlined$unsafeFlow$1.java

@@ -0,0 +1,170 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.jvm.functions.Function4;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__ErrorsKt$retryWhen$$inlined$unsafeFlow$1 implements Flow {
+    public final /* synthetic */ Function4 $predicate$inlined;
+    public final /* synthetic */ Flow $this_retryWhen$inlined;
+
+    /* renamed from: kotlinx.coroutines.flow.FlowKt__ErrorsKt$retryWhen$$inlined$unsafeFlow$1$1, reason: invalid class name */
+    public static final class AnonymousClass1 extends ContinuationImpl {
+        public int I$0;
+        public long J$0;
+        public Object L$0;
+        public Object L$1;
+        public Object L$2;
+        public int label;
+        public /* synthetic */ Object result;
+
+        public AnonymousClass1(Continuation continuation) {
+            super(continuation);
+        }
+
+        @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+        public final Object invokeSuspend(Object obj) {
+            this.result = obj;
+            this.label |= Integer.MIN_VALUE;
+            return FlowKt__ErrorsKt$retryWhen$$inlined$unsafeFlow$1.this.collect(null, this);
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:13:0x00a2  */
+    /* JADX WARN: Removed duplicated region for block: B:16:0x00ab  */
+    /* JADX WARN: Removed duplicated region for block: B:19:0x00ae  */
+    /* JADX WARN: Removed duplicated region for block: B:22:0x006e A[RETURN] */
+    /* JADX WARN: Removed duplicated region for block: B:23:0x006f  */
+    /* JADX WARN: Removed duplicated region for block: B:26:0x0078  */
+    /* JADX WARN: Removed duplicated region for block: B:30:0x00a8  */
+    /* JADX WARN: Removed duplicated region for block: B:34:0x0052  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0024  */
+    /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:25:0x0076 -> B:14:0x00a6). Please report as a decompilation issue!!! */
+    /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:29:0x0097 -> B:11:0x009a). Please report as a decompilation issue!!! */
+    @Override // kotlinx.coroutines.flow.Flow
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public java.lang.Object collect(kotlinx.coroutines.flow.FlowCollector r12, kotlin.coroutines.Continuation r13) {
+        /*
+            r11 = this;
+            boolean r0 = r13 instanceof kotlinx.coroutines.flow.FlowKt__ErrorsKt$retryWhen$$inlined$unsafeFlow$1.AnonymousClass1
+            if (r0 == 0) goto L13
+            r0 = r13
+            kotlinx.coroutines.flow.FlowKt__ErrorsKt$retryWhen$$inlined$unsafeFlow$1$1 r0 = (kotlinx.coroutines.flow.FlowKt__ErrorsKt$retryWhen$$inlined$unsafeFlow$1.AnonymousClass1) 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.FlowKt__ErrorsKt$retryWhen$$inlined$unsafeFlow$1$1 r0 = new kotlinx.coroutines.flow.FlowKt__ErrorsKt$retryWhen$$inlined$unsafeFlow$1$1
+            r0.<init>(r13)
+        L18:
+            java.lang.Object r13 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 2
+            r4 = 1
+            if (r2 == 0) goto L52
+            if (r2 == r4) goto L42
+            if (r2 != r3) goto L3a
+            long r5 = r0.J$0
+            java.lang.Object r12 = r0.L$2
+            java.lang.Throwable r12 = (java.lang.Throwable) r12
+            java.lang.Object r2 = r0.L$1
+            kotlinx.coroutines.flow.FlowCollector r2 = (kotlinx.coroutines.flow.FlowCollector) r2
+            java.lang.Object r7 = r0.L$0
+            kotlinx.coroutines.flow.FlowKt__ErrorsKt$retryWhen$$inlined$unsafeFlow$1 r7 = (kotlinx.coroutines.flow.FlowKt__ErrorsKt$retryWhen$$inlined$unsafeFlow$1) r7
+            kotlin.ResultKt.throwOnFailure(r13)
+            goto L9a
+        L3a:
+            java.lang.IllegalStateException r12 = new java.lang.IllegalStateException
+            java.lang.String r13 = "call to 'resume' before 'invoke' with coroutine"
+            r12.<init>(r13)
+            throw r12
+        L42:
+            int r12 = r0.I$0
+            long r5 = r0.J$0
+            java.lang.Object r2 = r0.L$1
+            kotlinx.coroutines.flow.FlowCollector r2 = (kotlinx.coroutines.flow.FlowCollector) r2
+            java.lang.Object r7 = r0.L$0
+            kotlinx.coroutines.flow.FlowKt__ErrorsKt$retryWhen$$inlined$unsafeFlow$1 r7 = (kotlinx.coroutines.flow.FlowKt__ErrorsKt$retryWhen$$inlined$unsafeFlow$1) r7
+            kotlin.ResultKt.throwOnFailure(r13)
+            goto L74
+        L52:
+            kotlin.ResultKt.throwOnFailure(r13)
+            r5 = 0
+            r13 = r11
+        L58:
+            kotlinx.coroutines.flow.Flow r2 = r13.$this_retryWhen$inlined
+            r0.L$0 = r13
+            r0.L$1 = r12
+            r7 = 0
+            r0.L$2 = r7
+            r0.J$0 = r5
+            r7 = 0
+            r0.I$0 = r7
+            r0.label = r4
+            java.lang.Object r2 = kotlinx.coroutines.flow.FlowKt.catchImpl(r2, r12, r0)
+            if (r2 != r1) goto L6f
+            return r1
+        L6f:
+            r10 = r2
+            r2 = r12
+            r12 = r7
+            r7 = r13
+            r13 = r10
+        L74:
+            java.lang.Throwable r13 = (java.lang.Throwable) r13
+            if (r13 == 0) goto La6
+            kotlin.jvm.functions.Function4 r12 = r7.$predicate$inlined
+            java.lang.Long r8 = kotlin.coroutines.jvm.internal.Boxing.boxLong(r5)
+            r0.L$0 = r7
+            r0.L$1 = r2
+            r0.L$2 = r13
+            r0.J$0 = r5
+            r0.label = r3
+            r9 = 6
+            kotlin.jvm.internal.InlineMarker.mark(r9)
+            java.lang.Object r12 = r12.invoke(r2, r13, r8, r0)
+            r8 = 7
+            kotlin.jvm.internal.InlineMarker.mark(r8)
+            if (r12 != r1) goto L97
+            return r1
+        L97:
+            r10 = r13
+            r13 = r12
+            r12 = r10
+        L9a:
+            java.lang.Boolean r13 = (java.lang.Boolean) r13
+            boolean r13 = r13.booleanValue()
+            if (r13 == 0) goto La8
+            r12 = 1
+            long r5 = r5 + r12
+            r12 = r4
+        La6:
+            r13 = r7
+            goto La9
+        La8:
+            throw r12
+        La9:
+            if (r12 != 0) goto Lae
+            kotlin.Unit r12 = kotlin.Unit.INSTANCE
+            return r12
+        Lae:
+            r12 = r2
+            goto L58
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__ErrorsKt$retryWhen$$inlined$unsafeFlow$1.collect(kotlinx.coroutines.flow.FlowCollector, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+
+    public FlowKt__ErrorsKt$retryWhen$$inlined$unsafeFlow$1(Flow flow, Function4 function4) {
+        this.$this_retryWhen$inlined = flow;
+        this.$predicate$inlined = function4;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__ErrorsKt.java

@@ -0,0 +1,114 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.CoroutineContext;
+import kotlin.jvm.functions.Function3;
+import kotlin.jvm.functions.Function4;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.Job;
+
+/* loaded from: classes5.dex */
+public abstract /* synthetic */ class FlowKt__ErrorsKt {
+    /* renamed from: catch, reason: not valid java name */
+    public static final Flow m4144catch(Flow flow, Function3 function3) {
+        return new FlowKt__ErrorsKt$catch$$inlined$unsafeFlow$1(flow, function3);
+    }
+
+    public static final Flow retryWhen(Flow flow, Function4 function4) {
+        return new FlowKt__ErrorsKt$retryWhen$$inlined$unsafeFlow$1(flow, function4);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Removed duplicated region for block: B:31:0x0037  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static final java.lang.Object catchImpl(kotlinx.coroutines.flow.Flow r4, kotlinx.coroutines.flow.FlowCollector r5, kotlin.coroutines.Continuation r6) {
+        /*
+            boolean r0 = r6 instanceof kotlinx.coroutines.flow.FlowKt__ErrorsKt$catchImpl$1
+            if (r0 == 0) goto L13
+            r0 = r6
+            kotlinx.coroutines.flow.FlowKt__ErrorsKt$catchImpl$1 r0 = (kotlinx.coroutines.flow.FlowKt__ErrorsKt$catchImpl$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.FlowKt__ErrorsKt$catchImpl$1 r0 = new kotlinx.coroutines.flow.FlowKt__ErrorsKt$catchImpl$1
+            r0.<init>(r6)
+        L18:
+            java.lang.Object r6 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 1
+            if (r2 == 0) goto L37
+            if (r2 != r3) goto L2f
+            java.lang.Object r4 = r0.L$0
+            kotlin.jvm.internal.Ref$ObjectRef r4 = (kotlin.jvm.internal.Ref.ObjectRef) r4
+            kotlin.ResultKt.throwOnFailure(r6)     // Catch: java.lang.Throwable -> L2d
+            goto L4f
+        L2d:
+            r5 = move-exception
+            goto L53
+        L2f:
+            java.lang.IllegalStateException r4 = new java.lang.IllegalStateException
+            java.lang.String r5 = "call to 'resume' before 'invoke' with coroutine"
+            r4.<init>(r5)
+            throw r4
+        L37:
+            kotlin.ResultKt.throwOnFailure(r6)
+            kotlin.jvm.internal.Ref$ObjectRef r6 = new kotlin.jvm.internal.Ref$ObjectRef
+            r6.<init>()
+            kotlinx.coroutines.flow.FlowKt__ErrorsKt$catchImpl$2 r2 = new kotlinx.coroutines.flow.FlowKt__ErrorsKt$catchImpl$2     // Catch: java.lang.Throwable -> L51
+            r2.<init>(r5, r6)     // Catch: java.lang.Throwable -> L51
+            r0.L$0 = r6     // Catch: java.lang.Throwable -> L51
+            r0.label = r3     // Catch: java.lang.Throwable -> L51
+            java.lang.Object r4 = r4.collect(r2, r0)     // Catch: java.lang.Throwable -> L51
+            if (r4 != r1) goto L4f
+            return r1
+        L4f:
+            r4 = 0
+            return r4
+        L51:
+            r5 = move-exception
+            r4 = r6
+        L53:
+            T r4 = r4.element
+            java.lang.Throwable r4 = (java.lang.Throwable) r4
+            boolean r6 = isSameExceptionAs$FlowKt__ErrorsKt(r5, r4)
+            if (r6 != 0) goto L76
+            kotlin.coroutines.CoroutineContext r6 = r0.getContext()
+            boolean r6 = isCancellationCause$FlowKt__ErrorsKt(r5, r6)
+            if (r6 != 0) goto L76
+            if (r4 != 0) goto L6a
+            return r5
+        L6a:
+            boolean r6 = r5 instanceof java.util.concurrent.CancellationException
+            if (r6 == 0) goto L72
+            kotlin.ExceptionsKt.addSuppressed(r4, r5)
+            throw r4
+        L72:
+            kotlin.ExceptionsKt.addSuppressed(r5, r4)
+            throw r5
+        L76:
+            throw r5
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__ErrorsKt.catchImpl(kotlinx.coroutines.flow.Flow, kotlinx.coroutines.flow.FlowCollector, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+
+    public static final boolean isSameExceptionAs$FlowKt__ErrorsKt(Throwable th, Throwable th2) {
+        return th2 != null && Intrinsics.areEqual(th2, th);
+    }
+
+    public static final boolean isCancellationCause$FlowKt__ErrorsKt(Throwable th, CoroutineContext coroutineContext) {
+        Job job = (Job) coroutineContext.get(Job.Key);
+        if (job == null || !job.isCancelled()) {
+            return false;
+        }
+        return isSameExceptionAs$FlowKt__ErrorsKt(th, job.getCancellationException());
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__LimitKt$dropWhile$1$1$emit$1.java

@@ -0,0 +1,26 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__LimitKt$dropWhile$1$1$emit$1 extends ContinuationImpl {
+    public Object L$0;
+    public Object L$1;
+    public int label;
+    public /* synthetic */ Object result;
+    public final /* synthetic */ FlowKt__LimitKt$dropWhile$1$1 this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public FlowKt__LimitKt$dropWhile$1$1$emit$1(FlowKt__LimitKt$dropWhile$1$1 flowKt__LimitKt$dropWhile$1$1, Continuation continuation) {
+        super(continuation);
+        this.this$0 = flowKt__LimitKt$dropWhile$1$1;
+    }
+
+    @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/FlowKt__LimitKt$dropWhile$1$1.java

@@ -0,0 +1,117 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Ref;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__LimitKt$dropWhile$1$1 implements FlowCollector {
+    public final /* synthetic */ Ref.BooleanRef $matched;
+    public final /* synthetic */ Function2 $predicate;
+    public final /* synthetic */ FlowCollector $this_unsafeFlow;
+
+    public FlowKt__LimitKt$dropWhile$1$1(Ref.BooleanRef booleanRef, FlowCollector flowCollector, Function2 function2) {
+        this.$matched = booleanRef;
+        this.$this_unsafeFlow = flowCollector;
+        this.$predicate = function2;
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:20:0x0074  */
+    /* JADX WARN: Removed duplicated region for block: B:23:0x008b  */
+    /* JADX WARN: Removed duplicated region for block: B:28:0x0045  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0025  */
+    @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.FlowKt__LimitKt$dropWhile$1$1$emit$1
+            if (r0 == 0) goto L13
+            r0 = r8
+            kotlinx.coroutines.flow.FlowKt__LimitKt$dropWhile$1$1$emit$1 r0 = (kotlinx.coroutines.flow.FlowKt__LimitKt$dropWhile$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.FlowKt__LimitKt$dropWhile$1$1$emit$1 r0 = new kotlinx.coroutines.flow.FlowKt__LimitKt$dropWhile$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 = 3
+            r4 = 2
+            r5 = 1
+            if (r2 == 0) goto L45
+            if (r2 == r5) goto L41
+            if (r2 == r4) goto L37
+            if (r2 != r3) goto L2f
+            kotlin.ResultKt.throwOnFailure(r8)
+            goto L88
+        L2f:
+            java.lang.IllegalStateException r7 = new java.lang.IllegalStateException
+            java.lang.String r8 = "call to 'resume' before 'invoke' with coroutine"
+            r7.<init>(r8)
+            throw r7
+        L37:
+            java.lang.Object r7 = r0.L$1
+            java.lang.Object r2 = r0.L$0
+            kotlinx.coroutines.flow.FlowKt__LimitKt$dropWhile$1$1 r2 = (kotlinx.coroutines.flow.FlowKt__LimitKt$dropWhile$1$1) r2
+            kotlin.ResultKt.throwOnFailure(r8)
+            goto L6c
+        L41:
+            kotlin.ResultKt.throwOnFailure(r8)
+            goto L59
+        L45:
+            kotlin.ResultKt.throwOnFailure(r8)
+            kotlin.jvm.internal.Ref$BooleanRef r8 = r6.$matched
+            boolean r8 = r8.element
+            if (r8 == 0) goto L5c
+            kotlinx.coroutines.flow.FlowCollector r8 = r6.$this_unsafeFlow
+            r0.label = r5
+            java.lang.Object r7 = r8.emit(r7, r0)
+            if (r7 != r1) goto L59
+            return r1
+        L59:
+            kotlin.Unit r7 = kotlin.Unit.INSTANCE
+            return r7
+        L5c:
+            kotlin.jvm.functions.Function2 r8 = r6.$predicate
+            r0.L$0 = r6
+            r0.L$1 = r7
+            r0.label = r4
+            java.lang.Object r8 = r8.invoke(r7, r0)
+            if (r8 != r1) goto L6b
+            return r1
+        L6b:
+            r2 = r6
+        L6c:
+            java.lang.Boolean r8 = (java.lang.Boolean) r8
+            boolean r8 = r8.booleanValue()
+            if (r8 != 0) goto L8b
+            kotlin.jvm.internal.Ref$BooleanRef r8 = r2.$matched
+            r8.element = r5
+            kotlinx.coroutines.flow.FlowCollector r8 = r2.$this_unsafeFlow
+            r2 = 0
+            r0.L$0 = r2
+            r0.L$1 = r2
+            r0.label = r3
+            java.lang.Object r7 = r8.emit(r7, r0)
+            if (r7 != r1) goto L88
+            return r1
+        L88:
+            kotlin.Unit r7 = kotlin.Unit.INSTANCE
+            return r7
+        L8b:
+            kotlin.Unit r7 = kotlin.Unit.INSTANCE
+            return r7
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__LimitKt$dropWhile$1$1.emit(java.lang.Object, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__LimitKt$emitAbort$1.java

@@ -0,0 +1,24 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__LimitKt$emitAbort$1 extends ContinuationImpl {
+    public Object L$0;
+    public int label;
+    public /* synthetic */ Object result;
+
+    public FlowKt__LimitKt$emitAbort$1(Continuation continuation) {
+        super(continuation);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object emitAbort$FlowKt__LimitKt;
+        this.result = obj;
+        this.label |= Integer.MIN_VALUE;
+        emitAbort$FlowKt__LimitKt = FlowKt__LimitKt.emitAbort$FlowKt__LimitKt(null, null, this);
+        return emitAbort$FlowKt__LimitKt;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__LimitKt$take$$inlined$unsafeFlow$1.java

@@ -0,0 +1,108 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__LimitKt$take$$inlined$unsafeFlow$1 implements Flow {
+    public final /* synthetic */ int $count$inlined;
+    public final /* synthetic */ Flow $this_take$inlined;
+
+    /* renamed from: kotlinx.coroutines.flow.FlowKt__LimitKt$take$$inlined$unsafeFlow$1$1, reason: invalid class name */
+    public static final class AnonymousClass1 extends ContinuationImpl {
+        public Object L$0;
+        public int label;
+        public /* synthetic */ Object result;
+
+        public AnonymousClass1(Continuation continuation) {
+            super(continuation);
+        }
+
+        @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+        public final Object invokeSuspend(Object obj) {
+            this.result = obj;
+            this.label |= Integer.MIN_VALUE;
+            return FlowKt__LimitKt$take$$inlined$unsafeFlow$1.this.collect(null, this);
+        }
+    }
+
+    /* JADX WARN: Can't wrap try/catch for region: R(10:0|1|(2:3|(7:5|6|7|(1:(2:10|11)(2:17|18))(3:19|20|(1:22))|12|13|14))|25|6|7|(0)(0)|12|13|14) */
+    /* JADX WARN: Code restructure failed: missing block: B:23:0x002d, code lost:
+    
+        r8 = move-exception;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:24:0x0053, code lost:
+    
+        kotlinx.coroutines.flow.internal.FlowExceptions_commonKt.checkOwnership(r8, r7);
+     */
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Removed duplicated region for block: B:19:0x0037  */
+    /* JADX WARN: Removed duplicated region for block: B:9:0x0023  */
+    @Override // kotlinx.coroutines.flow.Flow
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public java.lang.Object collect(kotlinx.coroutines.flow.FlowCollector r7, kotlin.coroutines.Continuation r8) {
+        /*
+            r6 = this;
+            boolean r0 = r8 instanceof kotlinx.coroutines.flow.FlowKt__LimitKt$take$$inlined$unsafeFlow$1.AnonymousClass1
+            if (r0 == 0) goto L13
+            r0 = r8
+            kotlinx.coroutines.flow.FlowKt__LimitKt$take$$inlined$unsafeFlow$1$1 r0 = (kotlinx.coroutines.flow.FlowKt__LimitKt$take$$inlined$unsafeFlow$1.AnonymousClass1) 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.FlowKt__LimitKt$take$$inlined$unsafeFlow$1$1 r0 = new kotlinx.coroutines.flow.FlowKt__LimitKt$take$$inlined$unsafeFlow$1$1
+            r0.<init>(r8)
+        L18:
+            java.lang.Object r8 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 1
+            if (r2 == 0) goto L37
+            if (r2 != r3) goto L2f
+            java.lang.Object r7 = r0.L$0
+            kotlinx.coroutines.flow.FlowCollector r7 = (kotlinx.coroutines.flow.FlowCollector) r7
+            kotlin.ResultKt.throwOnFailure(r8)     // Catch: kotlinx.coroutines.flow.internal.AbortFlowException -> L2d
+            goto L56
+        L2d:
+            r8 = move-exception
+            goto L53
+        L2f:
+            java.lang.IllegalStateException r7 = new java.lang.IllegalStateException
+            java.lang.String r8 = "call to 'resume' before 'invoke' with coroutine"
+            r7.<init>(r8)
+            throw r7
+        L37:
+            kotlin.ResultKt.throwOnFailure(r8)
+            kotlin.jvm.internal.Ref$IntRef r8 = new kotlin.jvm.internal.Ref$IntRef
+            r8.<init>()
+            kotlinx.coroutines.flow.Flow r2 = r6.$this_take$inlined     // Catch: kotlinx.coroutines.flow.internal.AbortFlowException -> L2d
+            kotlinx.coroutines.flow.FlowKt__LimitKt$take$2$1 r4 = new kotlinx.coroutines.flow.FlowKt__LimitKt$take$2$1     // Catch: kotlinx.coroutines.flow.internal.AbortFlowException -> L2d
+            int r5 = r6.$count$inlined     // Catch: kotlinx.coroutines.flow.internal.AbortFlowException -> L2d
+            r4.<init>(r8, r5, r7)     // Catch: kotlinx.coroutines.flow.internal.AbortFlowException -> L2d
+            r0.L$0 = r7     // Catch: kotlinx.coroutines.flow.internal.AbortFlowException -> L2d
+            r0.label = r3     // Catch: kotlinx.coroutines.flow.internal.AbortFlowException -> L2d
+            java.lang.Object r7 = r2.collect(r4, r0)     // Catch: kotlinx.coroutines.flow.internal.AbortFlowException -> L2d
+            if (r7 != r1) goto L56
+            return r1
+        L53:
+            kotlinx.coroutines.flow.internal.FlowExceptions_commonKt.checkOwnership(r8, r7)
+        L56:
+            kotlin.Unit r7 = kotlin.Unit.INSTANCE
+            return r7
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__LimitKt$take$$inlined$unsafeFlow$1.collect(kotlinx.coroutines.flow.FlowCollector, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+
+    public FlowKt__LimitKt$take$$inlined$unsafeFlow$1(Flow flow, int i) {
+        this.$this_take$inlined = flow;
+        this.$count$inlined = i;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__LimitKt$take$2$1$emit$1.java

@@ -0,0 +1,24 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__LimitKt$take$2$1$emit$1 extends ContinuationImpl {
+    public int label;
+    public /* synthetic */ Object result;
+    public final /* synthetic */ FlowKt__LimitKt$take$2$1 this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public FlowKt__LimitKt$take$2$1$emit$1(FlowKt__LimitKt$take$2$1 flowKt__LimitKt$take$2$1, Continuation continuation) {
+        super(continuation);
+        this.this$0 = flowKt__LimitKt$take$2$1;
+    }
+
+    @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/FlowKt__LimitKt$take$2$1.java

@@ -0,0 +1,88 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.jvm.internal.Ref;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__LimitKt$take$2$1 implements FlowCollector {
+    public final /* synthetic */ Ref.IntRef $consumed;
+    public final /* synthetic */ int $count;
+    public final /* synthetic */ FlowCollector $this_unsafeFlow;
+
+    public FlowKt__LimitKt$take$2$1(Ref.IntRef intRef, int i, FlowCollector flowCollector) {
+        this.$consumed = intRef;
+        this.$count = i;
+        this.$this_unsafeFlow = flowCollector;
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:19: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 r6, kotlin.coroutines.Continuation r7) {
+        /*
+            r5 = this;
+            boolean r0 = r7 instanceof kotlinx.coroutines.flow.FlowKt__LimitKt$take$2$1$emit$1
+            if (r0 == 0) goto L13
+            r0 = r7
+            kotlinx.coroutines.flow.FlowKt__LimitKt$take$2$1$emit$1 r0 = (kotlinx.coroutines.flow.FlowKt__LimitKt$take$2$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.FlowKt__LimitKt$take$2$1$emit$1 r0 = new kotlinx.coroutines.flow.FlowKt__LimitKt$take$2$1$emit$1
+            r0.<init>(r5, r7)
+        L18:
+            java.lang.Object r7 = 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(r7)
+            goto L5f
+        L2c:
+            java.lang.IllegalStateException r6 = new java.lang.IllegalStateException
+            java.lang.String r7 = "call to 'resume' before 'invoke' with coroutine"
+            r6.<init>(r7)
+            throw r6
+        L34:
+            kotlin.ResultKt.throwOnFailure(r7)
+            goto L51
+        L38:
+            kotlin.ResultKt.throwOnFailure(r7)
+            kotlin.jvm.internal.Ref$IntRef r7 = r5.$consumed
+            int r2 = r7.element
+            int r2 = r2 + r4
+            r7.element = r2
+            int r7 = r5.$count
+            if (r2 >= r7) goto L54
+            kotlinx.coroutines.flow.FlowCollector r7 = r5.$this_unsafeFlow
+            r0.label = r4
+            java.lang.Object r6 = r7.emit(r6, r0)
+            if (r6 != r1) goto L51
+            return r1
+        L51:
+            kotlin.Unit r6 = kotlin.Unit.INSTANCE
+            return r6
+        L54:
+            kotlinx.coroutines.flow.FlowCollector r7 = r5.$this_unsafeFlow
+            r0.label = r3
+            java.lang.Object r6 = kotlinx.coroutines.flow.FlowKt__LimitKt.access$emitAbort$FlowKt__LimitKt(r7, r6, r0)
+            if (r6 != r1) goto L5f
+            return r1
+        L5f:
+            kotlin.Unit r6 = kotlin.Unit.INSTANCE
+            return r6
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__LimitKt$take$2$1.emit(java.lang.Object, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1.java

@@ -0,0 +1,105 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.jvm.functions.Function3;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1 implements FlowCollector {
+    public final /* synthetic */ FlowCollector $$this$flow$inlined;
+    public final /* synthetic */ Function3 $transform$inlined;
+
+    /* renamed from: kotlinx.coroutines.flow.FlowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1$1, reason: invalid class name */
+    public static final class AnonymousClass1 extends ContinuationImpl {
+        public Object L$0;
+        public int label;
+        public /* synthetic */ Object result;
+
+        public AnonymousClass1(Continuation continuation) {
+            super(continuation);
+        }
+
+        @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+        public final Object invokeSuspend(Object obj) {
+            this.result = obj;
+            this.label |= Integer.MIN_VALUE;
+            return FlowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1.this.emit(null, this);
+        }
+    }
+
+    public FlowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1(Function3 function3, FlowCollector flowCollector) {
+        this.$transform$inlined = function3;
+        this.$$this$flow$inlined = flowCollector;
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:12:0x0058  */
+    /* JADX WARN: Removed duplicated region for block: B:15:0x005b  */
+    /* JADX WARN: Removed duplicated region for block: B:19:0x0035  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+    @Override // kotlinx.coroutines.flow.FlowCollector
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public java.lang.Object emit(java.lang.Object r5, kotlin.coroutines.Continuation r6) {
+        /*
+            r4 = this;
+            boolean r0 = r6 instanceof kotlinx.coroutines.flow.FlowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1.AnonymousClass1
+            if (r0 == 0) goto L13
+            r0 = r6
+            kotlinx.coroutines.flow.FlowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1$1 r0 = (kotlinx.coroutines.flow.FlowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1.AnonymousClass1) 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.FlowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1$1 r0 = new kotlinx.coroutines.flow.FlowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1$1
+            r0.<init>(r6)
+        L18:
+            java.lang.Object r6 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 1
+            if (r2 == 0) goto L35
+            if (r2 != r3) goto L2d
+            java.lang.Object r5 = r0.L$0
+            kotlinx.coroutines.flow.FlowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1 r5 = (kotlinx.coroutines.flow.FlowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1) r5
+            kotlin.ResultKt.throwOnFailure(r6)
+            goto L50
+        L2d:
+            java.lang.IllegalStateException r5 = new java.lang.IllegalStateException
+            java.lang.String r6 = "call to 'resume' before 'invoke' with coroutine"
+            r5.<init>(r6)
+            throw r5
+        L35:
+            kotlin.ResultKt.throwOnFailure(r6)
+            kotlin.jvm.functions.Function3 r6 = r4.$transform$inlined
+            kotlinx.coroutines.flow.FlowCollector r2 = r4.$$this$flow$inlined
+            r0.L$0 = r4
+            r0.label = r3
+            r3 = 6
+            kotlin.jvm.internal.InlineMarker.mark(r3)
+            java.lang.Object r6 = r6.invoke(r2, r5, r0)
+            r5 = 7
+            kotlin.jvm.internal.InlineMarker.mark(r5)
+            if (r6 != r1) goto L4f
+            return r1
+        L4f:
+            r5 = r4
+        L50:
+            java.lang.Boolean r6 = (java.lang.Boolean) r6
+            boolean r6 = r6.booleanValue()
+            if (r6 == 0) goto L5b
+            kotlin.Unit r5 = kotlin.Unit.INSTANCE
+            return r5
+        L5b:
+            kotlinx.coroutines.flow.internal.AbortFlowException r6 = new kotlinx.coroutines.flow.internal.AbortFlowException
+            r6.<init>(r5)
+            throw r6
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1.emit(java.lang.Object, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__LimitKt$transformWhile$1.java

@@ -0,0 +1,77 @@
+package kotlinx.coroutines.flow;
+
+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 kotlinx.coroutines.flow.internal.AbortFlowException;
+import kotlinx.coroutines.flow.internal.FlowExceptions_commonKt;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__LimitKt$transformWhile$1 extends SuspendLambda implements Function2 {
+    public final /* synthetic */ Flow $this_transformWhile;
+    public final /* synthetic */ Function3 $transform;
+    public /* synthetic */ Object L$0;
+    public int label;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public FlowKt__LimitKt$transformWhile$1(Flow flow, Function3 function3, Continuation continuation) {
+        super(2, continuation);
+        this.$this_transformWhile = flow;
+        this.$transform = function3;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        FlowKt__LimitKt$transformWhile$1 flowKt__LimitKt$transformWhile$1 = new FlowKt__LimitKt$transformWhile$1(this.$this_transformWhile, this.$transform, continuation);
+        flowKt__LimitKt$transformWhile$1.L$0 = obj;
+        return flowKt__LimitKt$transformWhile$1;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(FlowCollector flowCollector, Continuation continuation) {
+        return ((FlowKt__LimitKt$transformWhile$1) create(flowCollector, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended;
+        FlowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1 flowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1;
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.label;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            FlowCollector flowCollector = (FlowCollector) this.L$0;
+            Flow flow = this.$this_transformWhile;
+            FlowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1 flowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$12 = new FlowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1(this.$transform, flowCollector);
+            try {
+                this.L$0 = flowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$12;
+                this.label = 1;
+                if (flow.collect(flowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$12, this) == coroutine_suspended) {
+                    return coroutine_suspended;
+                }
+            } catch (AbortFlowException e) {
+                e = e;
+                flowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1 = flowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$12;
+                FlowExceptions_commonKt.checkOwnership(e, flowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1);
+                return Unit.INSTANCE;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            flowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1 = (FlowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1) this.L$0;
+            try {
+                ResultKt.throwOnFailure(obj);
+            } catch (AbortFlowException e2) {
+                e = e2;
+                FlowExceptions_commonKt.checkOwnership(e, flowKt__LimitKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1);
+                return Unit.INSTANCE;
+            }
+        }
+        return Unit.INSTANCE;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__LimitKt.java

@@ -0,0 +1,87 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.functions.Function3;
+import kotlin.jvm.internal.Ref;
+
+/* loaded from: classes5.dex */
+public abstract /* synthetic */ class FlowKt__LimitKt {
+    /* JADX WARN: Removed duplicated region for block: B:15:0x0035  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static final java.lang.Object emitAbort$FlowKt__LimitKt(kotlinx.coroutines.flow.FlowCollector r4, java.lang.Object r5, kotlin.coroutines.Continuation r6) {
+        /*
+            boolean r0 = r6 instanceof kotlinx.coroutines.flow.FlowKt__LimitKt$emitAbort$1
+            if (r0 == 0) goto L13
+            r0 = r6
+            kotlinx.coroutines.flow.FlowKt__LimitKt$emitAbort$1 r0 = (kotlinx.coroutines.flow.FlowKt__LimitKt$emitAbort$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.FlowKt__LimitKt$emitAbort$1 r0 = new kotlinx.coroutines.flow.FlowKt__LimitKt$emitAbort$1
+            r0.<init>(r6)
+        L18:
+            java.lang.Object r6 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 1
+            if (r2 == 0) goto L35
+            if (r2 == r3) goto L2d
+            java.lang.IllegalStateException r4 = new java.lang.IllegalStateException
+            java.lang.String r5 = "call to 'resume' before 'invoke' with coroutine"
+            r4.<init>(r5)
+            throw r4
+        L2d:
+            java.lang.Object r4 = r0.L$0
+            kotlinx.coroutines.flow.FlowCollector r4 = (kotlinx.coroutines.flow.FlowCollector) r4
+            kotlin.ResultKt.throwOnFailure(r6)
+            goto L43
+        L35:
+            kotlin.ResultKt.throwOnFailure(r6)
+            r0.L$0 = r4
+            r0.label = r3
+            java.lang.Object r5 = r4.emit(r5, r0)
+            if (r5 != r1) goto L43
+            return r1
+        L43:
+            kotlinx.coroutines.flow.internal.AbortFlowException r5 = new kotlinx.coroutines.flow.internal.AbortFlowException
+            r5.<init>(r4)
+            throw r5
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__LimitKt.emitAbort$FlowKt__LimitKt(kotlinx.coroutines.flow.FlowCollector, java.lang.Object, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+
+    public static final Flow dropWhile(final Flow flow, final Function2 function2) {
+        return new Flow() { // from class: kotlinx.coroutines.flow.FlowKt__LimitKt$dropWhile$$inlined$unsafeFlow$1
+            @Override // kotlinx.coroutines.flow.Flow
+            public Object collect(FlowCollector flowCollector, Continuation continuation) {
+                Object coroutine_suspended;
+                Object collect = Flow.this.collect(new FlowKt__LimitKt$dropWhile$1$1(new Ref.BooleanRef(), flowCollector, function2), continuation);
+                coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+                return collect == coroutine_suspended ? collect : Unit.INSTANCE;
+            }
+        };
+    }
+
+    public static final Flow take(Flow flow, int i) {
+        if (i <= 0) {
+            throw new IllegalArgumentException(("Requested element count " + i + " should be positive").toString());
+        }
+        return new FlowKt__LimitKt$take$$inlined$unsafeFlow$1(flow, i);
+    }
+
+    public static final Flow transformWhile(Flow flow, Function3 function3) {
+        return FlowKt.flow(new FlowKt__LimitKt$transformWhile$1(flow, function3, null));
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__MergeKt$mapLatest$1.java

@@ -0,0 +1,67 @@
+package kotlinx.coroutines.flow;
+
+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;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__MergeKt$mapLatest$1 extends SuspendLambda implements Function3 {
+    public final /* synthetic */ Function2 $transform;
+    public /* synthetic */ Object L$0;
+    public /* synthetic */ Object L$1;
+    public int label;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public FlowKt__MergeKt$mapLatest$1(Function2 function2, Continuation continuation) {
+        super(3, continuation);
+        this.$transform = function2;
+    }
+
+    @Override // kotlin.jvm.functions.Function3
+    public final Object invoke(FlowCollector flowCollector, Object obj, Continuation continuation) {
+        FlowKt__MergeKt$mapLatest$1 flowKt__MergeKt$mapLatest$1 = new FlowKt__MergeKt$mapLatest$1(this.$transform, continuation);
+        flowKt__MergeKt$mapLatest$1.L$0 = flowCollector;
+        flowKt__MergeKt$mapLatest$1.L$1 = obj;
+        return flowKt__MergeKt$mapLatest$1.invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended;
+        FlowCollector flowCollector;
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.label;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            flowCollector = (FlowCollector) this.L$0;
+            Object obj2 = this.L$1;
+            Function2 function2 = this.$transform;
+            this.L$0 = flowCollector;
+            this.label = 1;
+            obj = function2.invoke(obj2, this);
+            if (obj == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                if (i != 2) {
+                    throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+                }
+                ResultKt.throwOnFailure(obj);
+                return Unit.INSTANCE;
+            }
+            flowCollector = (FlowCollector) this.L$0;
+            ResultKt.throwOnFailure(obj);
+        }
+        this.L$0 = null;
+        this.label = 2;
+        if (flowCollector.emit(obj, this) == coroutine_suspended) {
+            return coroutine_suspended;
+        }
+        return Unit.INSTANCE;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__MergeKt.java

@@ -0,0 +1,19 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.functions.Function3;
+import kotlinx.coroutines.flow.internal.ChannelFlowTransformLatest;
+import kotlinx.coroutines.internal.SystemPropsKt;
+
+/* loaded from: classes5.dex */
+public abstract /* synthetic */ class FlowKt__MergeKt {
+    public static final int DEFAULT_CONCURRENCY = SystemPropsKt.systemProp("kotlinx.coroutines.flow.defaultConcurrency", 16, 1, Integer.MAX_VALUE);
+
+    public static final Flow transformLatest(Flow flow, Function3 function3) {
+        return new ChannelFlowTransformLatest(function3, flow, null, 0, null, 28, null);
+    }
+
+    public static final Flow mapLatest(Flow flow, Function2 function2) {
+        return FlowKt.transformLatest(flow, new FlowKt__MergeKt$mapLatest$1(function2, null));
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__ReduceKt$first$$inlined$collectWhile$2.java

@@ -0,0 +1,111 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Ref;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__ReduceKt$first$$inlined$collectWhile$2 implements FlowCollector {
+    public final /* synthetic */ Function2 $predicate$inlined;
+    public final /* synthetic */ Ref.ObjectRef $result$inlined;
+
+    /* renamed from: kotlinx.coroutines.flow.FlowKt__ReduceKt$first$$inlined$collectWhile$2$1, reason: invalid class name */
+    public static final class AnonymousClass1 extends ContinuationImpl {
+        public Object L$0;
+        public Object L$1;
+        public int label;
+        public /* synthetic */ Object result;
+
+        public AnonymousClass1(Continuation continuation) {
+            super(continuation);
+        }
+
+        @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+        public final Object invokeSuspend(Object obj) {
+            this.result = obj;
+            this.label |= Integer.MIN_VALUE;
+            return FlowKt__ReduceKt$first$$inlined$collectWhile$2.this.emit(null, this);
+        }
+    }
+
+    public FlowKt__ReduceKt$first$$inlined$collectWhile$2(Function2 function2, Ref.ObjectRef objectRef) {
+        this.$predicate$inlined = function2;
+        this.$result$inlined = objectRef;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Removed duplicated region for block: B:12:0x005a  */
+    /* JADX WARN: Removed duplicated region for block: B:15:0x005d  */
+    /* JADX WARN: Removed duplicated region for block: B:19:0x0037  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+    @Override // kotlinx.coroutines.flow.FlowCollector
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public java.lang.Object emit(java.lang.Object r5, kotlin.coroutines.Continuation r6) {
+        /*
+            r4 = this;
+            boolean r0 = r6 instanceof kotlinx.coroutines.flow.FlowKt__ReduceKt$first$$inlined$collectWhile$2.AnonymousClass1
+            if (r0 == 0) goto L13
+            r0 = r6
+            kotlinx.coroutines.flow.FlowKt__ReduceKt$first$$inlined$collectWhile$2$1 r0 = (kotlinx.coroutines.flow.FlowKt__ReduceKt$first$$inlined$collectWhile$2.AnonymousClass1) 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.FlowKt__ReduceKt$first$$inlined$collectWhile$2$1 r0 = new kotlinx.coroutines.flow.FlowKt__ReduceKt$first$$inlined$collectWhile$2$1
+            r0.<init>(r6)
+        L18:
+            java.lang.Object r6 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 1
+            if (r2 == 0) goto L37
+            if (r2 != r3) goto L2f
+            java.lang.Object r5 = r0.L$1
+            java.lang.Object r0 = r0.L$0
+            kotlinx.coroutines.flow.FlowKt__ReduceKt$first$$inlined$collectWhile$2 r0 = (kotlinx.coroutines.flow.FlowKt__ReduceKt$first$$inlined$collectWhile$2) r0
+            kotlin.ResultKt.throwOnFailure(r6)
+            goto L52
+        L2f:
+            java.lang.IllegalStateException r5 = new java.lang.IllegalStateException
+            java.lang.String r6 = "call to 'resume' before 'invoke' with coroutine"
+            r5.<init>(r6)
+            throw r5
+        L37:
+            kotlin.ResultKt.throwOnFailure(r6)
+            kotlin.jvm.functions.Function2 r6 = r4.$predicate$inlined
+            r0.L$0 = r4
+            r0.L$1 = r5
+            r0.label = r3
+            r2 = 6
+            kotlin.jvm.internal.InlineMarker.mark(r2)
+            java.lang.Object r6 = r6.invoke(r5, r0)
+            r0 = 7
+            kotlin.jvm.internal.InlineMarker.mark(r0)
+            if (r6 != r1) goto L51
+            return r1
+        L51:
+            r0 = r4
+        L52:
+            java.lang.Boolean r6 = (java.lang.Boolean) r6
+            boolean r6 = r6.booleanValue()
+            if (r6 != 0) goto L5d
+            kotlin.Unit r5 = kotlin.Unit.INSTANCE
+            return r5
+        L5d:
+            kotlin.jvm.internal.Ref$ObjectRef r6 = r0.$result$inlined
+            r6.element = r5
+            kotlinx.coroutines.flow.internal.AbortFlowException r5 = new kotlinx.coroutines.flow.internal.AbortFlowException
+            r5.<init>(r0)
+            throw r5
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__ReduceKt$first$$inlined$collectWhile$2.emit(java.lang.Object, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__ReduceKt$first$1.java

@@ -0,0 +1,23 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__ReduceKt$first$1 extends ContinuationImpl {
+    public Object L$0;
+    public Object L$1;
+    public int label;
+    public /* synthetic */ Object result;
+
+    public FlowKt__ReduceKt$first$1(Continuation continuation) {
+        super(continuation);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        this.result = obj;
+        this.label |= Integer.MIN_VALUE;
+        return FlowKt.first(null, this);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__ReduceKt$first$3.java

@@ -0,0 +1,24 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__ReduceKt$first$3 extends ContinuationImpl {
+    public Object L$0;
+    public Object L$1;
+    public Object L$2;
+    public int label;
+    public /* synthetic */ Object result;
+
+    public FlowKt__ReduceKt$first$3(Continuation continuation) {
+        super(continuation);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        this.result = obj;
+        this.label |= Integer.MIN_VALUE;
+        return FlowKt.first(null, null, this);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__ReduceKt$single$1.java

@@ -0,0 +1,22 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__ReduceKt$single$1 extends ContinuationImpl {
+    public Object L$0;
+    public int label;
+    public /* synthetic */ Object result;
+
+    public FlowKt__ReduceKt$single$1(Continuation continuation) {
+        super(continuation);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        this.result = obj;
+        this.label |= Integer.MIN_VALUE;
+        return FlowKt.single(null, this);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__ReduceKt.java

@@ -0,0 +1,252 @@
+package kotlinx.coroutines.flow;
+
+/* loaded from: classes5.dex */
+public abstract /* synthetic */ class FlowKt__ReduceKt {
+    /* JADX WARN: Removed duplicated region for block: B:12:0x0058 A[RETURN] */
+    /* JADX WARN: Removed duplicated region for block: B:14:0x0059  */
+    /* JADX WARN: Removed duplicated region for block: B:18:0x0035  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+    /* JADX WARN: Type inference failed for: r2v1, types: [T, kotlinx.coroutines.internal.Symbol] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static final java.lang.Object single(kotlinx.coroutines.flow.Flow r4, kotlin.coroutines.Continuation r5) {
+        /*
+            boolean r0 = r5 instanceof kotlinx.coroutines.flow.FlowKt__ReduceKt$single$1
+            if (r0 == 0) goto L13
+            r0 = r5
+            kotlinx.coroutines.flow.FlowKt__ReduceKt$single$1 r0 = (kotlinx.coroutines.flow.FlowKt__ReduceKt$single$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.FlowKt__ReduceKt$single$1 r0 = new kotlinx.coroutines.flow.FlowKt__ReduceKt$single$1
+            r0.<init>(r5)
+        L18:
+            java.lang.Object r5 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 1
+            if (r2 == 0) goto L35
+            if (r2 != r3) goto L2d
+            java.lang.Object r4 = r0.L$0
+            kotlin.jvm.internal.Ref$ObjectRef r4 = (kotlin.jvm.internal.Ref.ObjectRef) r4
+            kotlin.ResultKt.throwOnFailure(r5)
+            goto L52
+        L2d:
+            java.lang.IllegalStateException r4 = new java.lang.IllegalStateException
+            java.lang.String r5 = "call to 'resume' before 'invoke' with coroutine"
+            r4.<init>(r5)
+            throw r4
+        L35:
+            kotlin.ResultKt.throwOnFailure(r5)
+            kotlin.jvm.internal.Ref$ObjectRef r5 = new kotlin.jvm.internal.Ref$ObjectRef
+            r5.<init>()
+            kotlinx.coroutines.internal.Symbol r2 = kotlinx.coroutines.flow.internal.NullSurrogateKt.NULL
+            r5.element = r2
+            kotlinx.coroutines.flow.FlowKt__ReduceKt$single$2 r2 = new kotlinx.coroutines.flow.FlowKt__ReduceKt$single$2
+            r2.<init>()
+            r0.L$0 = r5
+            r0.label = r3
+            java.lang.Object r4 = r4.collect(r2, r0)
+            if (r4 != r1) goto L51
+            return r1
+        L51:
+            r4 = r5
+        L52:
+            T r4 = r4.element
+            kotlinx.coroutines.internal.Symbol r5 = kotlinx.coroutines.flow.internal.NullSurrogateKt.NULL
+            if (r4 == r5) goto L59
+            return r4
+        L59:
+            java.util.NoSuchElementException r4 = new java.util.NoSuchElementException
+            java.lang.String r5 = "Flow is empty"
+            r4.<init>(r5)
+            throw r4
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__ReduceKt.single(kotlinx.coroutines.flow.Flow, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:14:0x0068 A[RETURN] */
+    /* JADX WARN: Removed duplicated region for block: B:16:0x0069  */
+    /* JADX WARN: Removed duplicated region for block: B:23:0x003b  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+    /* JADX WARN: Type inference failed for: r2v1, types: [T, kotlinx.coroutines.internal.Symbol] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static final java.lang.Object first(kotlinx.coroutines.flow.Flow r4, kotlin.coroutines.Continuation r5) {
+        /*
+            boolean r0 = r5 instanceof kotlinx.coroutines.flow.FlowKt__ReduceKt$first$1
+            if (r0 == 0) goto L13
+            r0 = r5
+            kotlinx.coroutines.flow.FlowKt__ReduceKt$first$1 r0 = (kotlinx.coroutines.flow.FlowKt__ReduceKt$first$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.FlowKt__ReduceKt$first$1 r0 = new kotlinx.coroutines.flow.FlowKt__ReduceKt$first$1
+            r0.<init>(r5)
+        L18:
+            java.lang.Object r5 = 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 r4 = r0.L$1
+            kotlinx.coroutines.flow.FlowKt__ReduceKt$first$$inlined$collectWhile$1 r4 = (kotlinx.coroutines.flow.FlowKt__ReduceKt$first$$inlined$collectWhile$1) r4
+            java.lang.Object r0 = r0.L$0
+            kotlin.jvm.internal.Ref$ObjectRef r0 = (kotlin.jvm.internal.Ref.ObjectRef) r0
+            kotlin.ResultKt.throwOnFailure(r5)     // Catch: kotlinx.coroutines.flow.internal.AbortFlowException -> L31
+            goto L62
+        L31:
+            r5 = move-exception
+            goto L5f
+        L33:
+            java.lang.IllegalStateException r4 = new java.lang.IllegalStateException
+            java.lang.String r5 = "call to 'resume' before 'invoke' with coroutine"
+            r4.<init>(r5)
+            throw r4
+        L3b:
+            kotlin.ResultKt.throwOnFailure(r5)
+            kotlin.jvm.internal.Ref$ObjectRef r5 = new kotlin.jvm.internal.Ref$ObjectRef
+            r5.<init>()
+            kotlinx.coroutines.internal.Symbol r2 = kotlinx.coroutines.flow.internal.NullSurrogateKt.NULL
+            r5.element = r2
+            kotlinx.coroutines.flow.FlowKt__ReduceKt$first$$inlined$collectWhile$1 r2 = new kotlinx.coroutines.flow.FlowKt__ReduceKt$first$$inlined$collectWhile$1
+            r2.<init>()
+            r0.L$0 = r5     // Catch: kotlinx.coroutines.flow.internal.AbortFlowException -> L5b
+            r0.L$1 = r2     // Catch: kotlinx.coroutines.flow.internal.AbortFlowException -> L5b
+            r0.label = r3     // Catch: kotlinx.coroutines.flow.internal.AbortFlowException -> L5b
+            java.lang.Object r4 = r4.collect(r2, r0)     // Catch: kotlinx.coroutines.flow.internal.AbortFlowException -> L5b
+            if (r4 != r1) goto L59
+            return r1
+        L59:
+            r0 = r5
+            goto L62
+        L5b:
+            r4 = move-exception
+            r0 = r5
+            r5 = r4
+            r4 = r2
+        L5f:
+            kotlinx.coroutines.flow.internal.FlowExceptions_commonKt.checkOwnership(r5, r4)
+        L62:
+            T r4 = r0.element
+            kotlinx.coroutines.internal.Symbol r5 = kotlinx.coroutines.flow.internal.NullSurrogateKt.NULL
+            if (r4 == r5) goto L69
+            return r4
+        L69:
+            java.util.NoSuchElementException r4 = new java.util.NoSuchElementException
+            java.lang.String r5 = "Expected at least one element"
+            r4.<init>(r5)
+            throw r4
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__ReduceKt.first(kotlinx.coroutines.flow.Flow, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:14:0x0070 A[RETURN] */
+    /* JADX WARN: Removed duplicated region for block: B:16:0x0071  */
+    /* JADX WARN: Removed duplicated region for block: B:23:0x003f  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+    /* JADX WARN: Type inference failed for: r2v1, types: [T, kotlinx.coroutines.internal.Symbol] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static final java.lang.Object first(kotlinx.coroutines.flow.Flow r4, kotlin.jvm.functions.Function2 r5, kotlin.coroutines.Continuation r6) {
+        /*
+            boolean r0 = r6 instanceof kotlinx.coroutines.flow.FlowKt__ReduceKt$first$3
+            if (r0 == 0) goto L13
+            r0 = r6
+            kotlinx.coroutines.flow.FlowKt__ReduceKt$first$3 r0 = (kotlinx.coroutines.flow.FlowKt__ReduceKt$first$3) 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.FlowKt__ReduceKt$first$3 r0 = new kotlinx.coroutines.flow.FlowKt__ReduceKt$first$3
+            r0.<init>(r6)
+        L18:
+            java.lang.Object r6 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 1
+            if (r2 == 0) goto L3f
+            if (r2 != r3) goto L37
+            java.lang.Object r4 = r0.L$2
+            kotlinx.coroutines.flow.FlowKt__ReduceKt$first$$inlined$collectWhile$2 r4 = (kotlinx.coroutines.flow.FlowKt__ReduceKt$first$$inlined$collectWhile$2) r4
+            java.lang.Object r5 = r0.L$1
+            kotlin.jvm.internal.Ref$ObjectRef r5 = (kotlin.jvm.internal.Ref.ObjectRef) r5
+            java.lang.Object r0 = r0.L$0
+            kotlin.jvm.functions.Function2 r0 = (kotlin.jvm.functions.Function2) r0
+            kotlin.ResultKt.throwOnFailure(r6)     // Catch: kotlinx.coroutines.flow.internal.AbortFlowException -> L35
+            goto L6a
+        L35:
+            r6 = move-exception
+            goto L67
+        L37:
+            java.lang.IllegalStateException r4 = new java.lang.IllegalStateException
+            java.lang.String r5 = "call to 'resume' before 'invoke' with coroutine"
+            r4.<init>(r5)
+            throw r4
+        L3f:
+            kotlin.ResultKt.throwOnFailure(r6)
+            kotlin.jvm.internal.Ref$ObjectRef r6 = new kotlin.jvm.internal.Ref$ObjectRef
+            r6.<init>()
+            kotlinx.coroutines.internal.Symbol r2 = kotlinx.coroutines.flow.internal.NullSurrogateKt.NULL
+            r6.element = r2
+            kotlinx.coroutines.flow.FlowKt__ReduceKt$first$$inlined$collectWhile$2 r2 = new kotlinx.coroutines.flow.FlowKt__ReduceKt$first$$inlined$collectWhile$2
+            r2.<init>(r5, r6)
+            r0.L$0 = r5     // Catch: kotlinx.coroutines.flow.internal.AbortFlowException -> L62
+            r0.L$1 = r6     // Catch: kotlinx.coroutines.flow.internal.AbortFlowException -> L62
+            r0.L$2 = r2     // Catch: kotlinx.coroutines.flow.internal.AbortFlowException -> L62
+            r0.label = r3     // Catch: kotlinx.coroutines.flow.internal.AbortFlowException -> L62
+            java.lang.Object r4 = r4.collect(r2, r0)     // Catch: kotlinx.coroutines.flow.internal.AbortFlowException -> L62
+            if (r4 != r1) goto L5f
+            return r1
+        L5f:
+            r0 = r5
+            r5 = r6
+            goto L6a
+        L62:
+            r4 = move-exception
+            r0 = r5
+            r5 = r6
+            r6 = r4
+            r4 = r2
+        L67:
+            kotlinx.coroutines.flow.internal.FlowExceptions_commonKt.checkOwnership(r6, r4)
+        L6a:
+            T r4 = r5.element
+            kotlinx.coroutines.internal.Symbol r5 = kotlinx.coroutines.flow.internal.NullSurrogateKt.NULL
+            if (r4 == r5) goto L71
+            return r4
+        L71:
+            java.util.NoSuchElementException r4 = new java.util.NoSuchElementException
+            java.lang.StringBuilder r5 = new java.lang.StringBuilder
+            r5.<init>()
+            java.lang.String r6 = "Expected at least one element matching the predicate "
+            r5.append(r6)
+            r5.append(r0)
+            java.lang.String r5 = r5.toString()
+            r4.<init>(r5)
+            throw r4
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__ReduceKt.first(kotlinx.coroutines.flow.Flow, kotlin.jvm.functions.Function2, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__ShareKt$launchSharing$1.java

@@ -0,0 +1,243 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.Boxing;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__ShareKt$launchSharing$1 extends SuspendLambda implements Function2 {
+    public final /* synthetic */ Object $initialValue;
+    public final /* synthetic */ MutableSharedFlow $shared;
+    public final /* synthetic */ SharingStarted $started;
+    public final /* synthetic */ Flow $upstream;
+    public int label;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public FlowKt__ShareKt$launchSharing$1(SharingStarted sharingStarted, Flow flow, MutableSharedFlow mutableSharedFlow, Object obj, Continuation continuation) {
+        super(2, continuation);
+        this.$started = sharingStarted;
+        this.$upstream = flow;
+        this.$shared = mutableSharedFlow;
+        this.$initialValue = obj;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new FlowKt__ShareKt$launchSharing$1(this.$started, this.$upstream, this.$shared, this.$initialValue, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(CoroutineScope coroutineScope, Continuation continuation) {
+        return ((FlowKt__ShareKt$launchSharing$1) create(coroutineScope, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:13:0x0068 A[RETURN] */
+    @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 r8) {
+        /*
+            r7 = this;
+            java.lang.Object r0 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r1 = r7.label
+            r2 = 4
+            r3 = 3
+            r4 = 2
+            r5 = 1
+            if (r1 == 0) goto L25
+            if (r1 == r5) goto L21
+            if (r1 == r4) goto L1d
+            if (r1 == r3) goto L21
+            if (r1 != r2) goto L15
+            goto L21
+        L15:
+            java.lang.IllegalStateException r8 = new java.lang.IllegalStateException
+            java.lang.String r0 = "call to 'resume' before 'invoke' with coroutine"
+            r8.<init>(r0)
+            throw r8
+        L1d:
+            kotlin.ResultKt.throwOnFailure(r8)
+            goto L5c
+        L21:
+            kotlin.ResultKt.throwOnFailure(r8)
+            goto L8d
+        L25:
+            kotlin.ResultKt.throwOnFailure(r8)
+            kotlinx.coroutines.flow.SharingStarted r8 = r7.$started
+            kotlinx.coroutines.flow.SharingStarted$Companion r1 = kotlinx.coroutines.flow.SharingStarted.Companion
+            kotlinx.coroutines.flow.SharingStarted r6 = r1.getEagerly()
+            if (r8 != r6) goto L3f
+            kotlinx.coroutines.flow.Flow r8 = r7.$upstream
+            kotlinx.coroutines.flow.MutableSharedFlow r1 = r7.$shared
+            r7.label = r5
+            java.lang.Object r8 = r8.collect(r1, r7)
+            if (r8 != r0) goto L8d
+            return r0
+        L3f:
+            kotlinx.coroutines.flow.SharingStarted r8 = r7.$started
+            kotlinx.coroutines.flow.SharingStarted r1 = r1.getLazily()
+            r5 = 0
+            if (r8 != r1) goto L69
+            kotlinx.coroutines.flow.MutableSharedFlow r8 = r7.$shared
+            kotlinx.coroutines.flow.StateFlow r8 = r8.getSubscriptionCount()
+            kotlinx.coroutines.flow.FlowKt__ShareKt$launchSharing$1$1 r1 = new kotlinx.coroutines.flow.FlowKt__ShareKt$launchSharing$1$1
+            r1.<init>(r5)
+            r7.label = r4
+            java.lang.Object r8 = kotlinx.coroutines.flow.FlowKt.first(r8, r1, r7)
+            if (r8 != r0) goto L5c
+            return r0
+        L5c:
+            kotlinx.coroutines.flow.Flow r8 = r7.$upstream
+            kotlinx.coroutines.flow.MutableSharedFlow r1 = r7.$shared
+            r7.label = r3
+            java.lang.Object r8 = r8.collect(r1, r7)
+            if (r8 != r0) goto L8d
+            return r0
+        L69:
+            kotlinx.coroutines.flow.SharingStarted r8 = r7.$started
+            kotlinx.coroutines.flow.MutableSharedFlow r1 = r7.$shared
+            kotlinx.coroutines.flow.StateFlow r1 = r1.getSubscriptionCount()
+            kotlinx.coroutines.flow.Flow r8 = r8.command(r1)
+            kotlinx.coroutines.flow.Flow r8 = kotlinx.coroutines.flow.FlowKt.distinctUntilChanged(r8)
+            kotlinx.coroutines.flow.FlowKt__ShareKt$launchSharing$1$2 r1 = new kotlinx.coroutines.flow.FlowKt__ShareKt$launchSharing$1$2
+            kotlinx.coroutines.flow.Flow r3 = r7.$upstream
+            kotlinx.coroutines.flow.MutableSharedFlow r4 = r7.$shared
+            java.lang.Object r6 = r7.$initialValue
+            r1.<init>(r3, r4, r6, r5)
+            r7.label = r2
+            java.lang.Object r8 = kotlinx.coroutines.flow.FlowKt.collectLatest(r8, r1, r7)
+            if (r8 != r0) goto L8d
+            return r0
+        L8d:
+            kotlin.Unit r8 = kotlin.Unit.INSTANCE
+            return r8
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__ShareKt$launchSharing$1.invokeSuspend(java.lang.Object):java.lang.Object");
+    }
+
+    /* renamed from: kotlinx.coroutines.flow.FlowKt__ShareKt$launchSharing$1$1, reason: invalid class name */
+    public static final class AnonymousClass1 extends SuspendLambda implements Function2 {
+        public /* synthetic */ int I$0;
+        public int label;
+
+        public AnonymousClass1(Continuation continuation) {
+            super(2, continuation);
+        }
+
+        @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+        public final Continuation create(Object obj, Continuation continuation) {
+            AnonymousClass1 anonymousClass1 = new AnonymousClass1(continuation);
+            anonymousClass1.I$0 = ((Number) obj).intValue();
+            return anonymousClass1;
+        }
+
+        public final Object invoke(int i, Continuation continuation) {
+            return ((AnonymousClass1) create(Integer.valueOf(i), continuation)).invokeSuspend(Unit.INSTANCE);
+        }
+
+        @Override // kotlin.jvm.functions.Function2
+        public /* bridge */ /* synthetic */ Object invoke(Object obj, Object obj2) {
+            return invoke(((Number) obj).intValue(), (Continuation) obj2);
+        }
+
+        @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+        public final Object invokeSuspend(Object obj) {
+            IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+            if (this.label != 0) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+            return Boxing.boxBoolean(this.I$0 > 0);
+        }
+    }
+
+    /* renamed from: kotlinx.coroutines.flow.FlowKt__ShareKt$launchSharing$1$2, reason: invalid class name */
+    public static final class AnonymousClass2 extends SuspendLambda implements Function2 {
+        public final /* synthetic */ Object $initialValue;
+        public final /* synthetic */ MutableSharedFlow $shared;
+        public final /* synthetic */ Flow $upstream;
+        public /* synthetic */ Object L$0;
+        public int label;
+
+        /* renamed from: kotlinx.coroutines.flow.FlowKt__ShareKt$launchSharing$1$2$WhenMappings */
+        public /* synthetic */ class WhenMappings {
+            public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+            static {
+                int[] iArr = new int[SharingCommand.values().length];
+                try {
+                    iArr[SharingCommand.START.ordinal()] = 1;
+                } catch (NoSuchFieldError unused) {
+                }
+                try {
+                    iArr[SharingCommand.STOP.ordinal()] = 2;
+                } catch (NoSuchFieldError unused2) {
+                }
+                try {
+                    iArr[SharingCommand.STOP_AND_RESET_REPLAY_CACHE.ordinal()] = 3;
+                } catch (NoSuchFieldError unused3) {
+                }
+                $EnumSwitchMapping$0 = iArr;
+            }
+        }
+
+        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+        public AnonymousClass2(Flow flow, MutableSharedFlow mutableSharedFlow, Object obj, Continuation continuation) {
+            super(2, continuation);
+            this.$upstream = flow;
+            this.$shared = mutableSharedFlow;
+            this.$initialValue = obj;
+        }
+
+        @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+        public final Continuation create(Object obj, Continuation continuation) {
+            AnonymousClass2 anonymousClass2 = new AnonymousClass2(this.$upstream, this.$shared, this.$initialValue, continuation);
+            anonymousClass2.L$0 = obj;
+            return anonymousClass2;
+        }
+
+        @Override // kotlin.jvm.functions.Function2
+        public final Object invoke(SharingCommand sharingCommand, Continuation continuation) {
+            return ((AnonymousClass2) create(sharingCommand, 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);
+                int i2 = WhenMappings.$EnumSwitchMapping$0[((SharingCommand) this.L$0).ordinal()];
+                if (i2 == 1) {
+                    Flow flow = this.$upstream;
+                    MutableSharedFlow mutableSharedFlow = this.$shared;
+                    this.label = 1;
+                    if (flow.collect(mutableSharedFlow, this) == coroutine_suspended) {
+                        return coroutine_suspended;
+                    }
+                } else if (i2 == 3) {
+                    Object obj2 = this.$initialValue;
+                    if (obj2 == SharedFlowKt.NO_VALUE) {
+                        this.$shared.resetReplayCache();
+                    } else {
+                        this.$shared.tryEmit(obj2);
+                    }
+                }
+            } 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/FlowKt__ShareKt.java

@@ -0,0 +1,90 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.CoroutineContext;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.BuildersKt;
+import kotlinx.coroutines.CoroutineScope;
+import kotlinx.coroutines.CoroutineStart;
+import kotlinx.coroutines.Job;
+
+/* loaded from: classes5.dex */
+public abstract /* synthetic */ class FlowKt__ShareKt {
+    public static final SharedFlow shareIn(Flow flow, CoroutineScope coroutineScope, SharingStarted sharingStarted, int i) {
+        SharingConfig configureSharing$FlowKt__ShareKt = configureSharing$FlowKt__ShareKt(flow, i);
+        MutableSharedFlow MutableSharedFlow = SharedFlowKt.MutableSharedFlow(i, configureSharing$FlowKt__ShareKt.extraBufferCapacity, configureSharing$FlowKt__ShareKt.onBufferOverflow);
+        return new ReadonlySharedFlow(MutableSharedFlow, launchSharing$FlowKt__ShareKt(coroutineScope, configureSharing$FlowKt__ShareKt.context, configureSharing$FlowKt__ShareKt.upstream, MutableSharedFlow, sharingStarted, SharedFlowKt.NO_VALUE));
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:16:0x002d, code lost:
+    
+        if (r3 == 0) goto L15;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static final kotlinx.coroutines.flow.SharingConfig configureSharing$FlowKt__ShareKt(kotlinx.coroutines.flow.Flow r7, int r8) {
+        /*
+            kotlinx.coroutines.channels.Channel$Factory r0 = kotlinx.coroutines.channels.Channel.Factory
+            int r0 = r0.getCHANNEL_DEFAULT_CAPACITY$kotlinx_coroutines_core()
+            int r0 = kotlin.ranges.RangesKt.coerceAtLeast(r8, r0)
+            int r0 = r0 - r8
+            boolean r1 = r7 instanceof kotlinx.coroutines.flow.internal.ChannelFlow
+            if (r1 == 0) goto L3c
+            r1 = r7
+            kotlinx.coroutines.flow.internal.ChannelFlow r1 = (kotlinx.coroutines.flow.internal.ChannelFlow) r1
+            kotlinx.coroutines.flow.Flow r2 = r1.dropChannelOperators()
+            if (r2 == 0) goto L3c
+            kotlinx.coroutines.flow.SharingConfig r7 = new kotlinx.coroutines.flow.SharingConfig
+            int r3 = r1.capacity
+            r4 = -3
+            if (r3 == r4) goto L26
+            r4 = -2
+            if (r3 == r4) goto L26
+            if (r3 == 0) goto L26
+            r0 = r3
+            goto L34
+        L26:
+            kotlinx.coroutines.channels.BufferOverflow r4 = r1.onBufferOverflow
+            kotlinx.coroutines.channels.BufferOverflow r5 = kotlinx.coroutines.channels.BufferOverflow.SUSPEND
+            r6 = 0
+            if (r4 != r5) goto L31
+            if (r3 != 0) goto L34
+        L2f:
+            r0 = r6
+            goto L34
+        L31:
+            if (r8 != 0) goto L2f
+            r0 = 1
+        L34:
+            kotlinx.coroutines.channels.BufferOverflow r8 = r1.onBufferOverflow
+            kotlin.coroutines.CoroutineContext r1 = r1.context
+            r7.<init>(r2, r0, r8, r1)
+            return r7
+        L3c:
+            kotlinx.coroutines.flow.SharingConfig r8 = new kotlinx.coroutines.flow.SharingConfig
+            kotlinx.coroutines.channels.BufferOverflow r1 = kotlinx.coroutines.channels.BufferOverflow.SUSPEND
+            kotlin.coroutines.EmptyCoroutineContext r2 = kotlin.coroutines.EmptyCoroutineContext.INSTANCE
+            r8.<init>(r7, r0, r1, r2)
+            return r8
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__ShareKt.configureSharing$FlowKt__ShareKt(kotlinx.coroutines.flow.Flow, int):kotlinx.coroutines.flow.SharingConfig");
+    }
+
+    public static final Job launchSharing$FlowKt__ShareKt(CoroutineScope coroutineScope, CoroutineContext coroutineContext, Flow flow, MutableSharedFlow mutableSharedFlow, SharingStarted sharingStarted, Object obj) {
+        return BuildersKt.launch(coroutineScope, coroutineContext, Intrinsics.areEqual(sharingStarted, SharingStarted.Companion.getEagerly()) ? CoroutineStart.DEFAULT : CoroutineStart.UNDISPATCHED, new FlowKt__ShareKt$launchSharing$1(sharingStarted, flow, mutableSharedFlow, obj, null));
+    }
+
+    public static final SharedFlow asSharedFlow(MutableSharedFlow mutableSharedFlow) {
+        return new ReadonlySharedFlow(mutableSharedFlow, null);
+    }
+
+    public static final StateFlow asStateFlow(MutableStateFlow mutableStateFlow) {
+        return new ReadonlyStateFlow(mutableStateFlow, null);
+    }
+
+    public static final SharedFlow onSubscription(SharedFlow sharedFlow, Function2 function2) {
+        return new SubscribedSharedFlow(sharedFlow, function2);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__TransformKt.java

@@ -0,0 +1,132 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.jvm.functions.Function2;
+
+/* loaded from: classes5.dex */
+public abstract /* synthetic */ class FlowKt__TransformKt {
+    public static final Flow onEach(final Flow flow, final Function2 function2) {
+        return new Flow() { // from class: kotlinx.coroutines.flow.FlowKt__TransformKt$onEach$$inlined$unsafeTransform$1
+
+            /* renamed from: kotlinx.coroutines.flow.FlowKt__TransformKt$onEach$$inlined$unsafeTransform$1$2, reason: invalid class name */
+            public static final class AnonymousClass2 implements FlowCollector {
+                public final /* synthetic */ Function2 $action$inlined;
+                public final /* synthetic */ FlowCollector $this_unsafeFlow;
+
+                /* renamed from: kotlinx.coroutines.flow.FlowKt__TransformKt$onEach$$inlined$unsafeTransform$1$2$1, reason: invalid class name */
+                public static final class AnonymousClass1 extends ContinuationImpl {
+                    public Object L$0;
+                    public Object L$1;
+                    public int label;
+                    public /* synthetic */ Object result;
+
+                    public AnonymousClass1(Continuation continuation) {
+                        super(continuation);
+                    }
+
+                    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+                    public final Object invokeSuspend(Object obj) {
+                        this.result = obj;
+                        this.label |= Integer.MIN_VALUE;
+                        return AnonymousClass2.this.emit(null, this);
+                    }
+                }
+
+                public AnonymousClass2(FlowCollector flowCollector, Function2 function2) {
+                    this.$this_unsafeFlow = flowCollector;
+                    this.$action$inlined = function2;
+                }
+
+                /* JADX WARN: Removed duplicated region for block: B:19:0x0069 A[RETURN] */
+                /* JADX WARN: Removed duplicated region for block: B:20:0x003e  */
+                /* 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 r6, kotlin.coroutines.Continuation r7) {
+                    /*
+                        r5 = this;
+                        boolean r0 = r7 instanceof kotlinx.coroutines.flow.FlowKt__TransformKt$onEach$$inlined$unsafeTransform$1.AnonymousClass2.AnonymousClass1
+                        if (r0 == 0) goto L13
+                        r0 = r7
+                        kotlinx.coroutines.flow.FlowKt__TransformKt$onEach$$inlined$unsafeTransform$1$2$1 r0 = (kotlinx.coroutines.flow.FlowKt__TransformKt$onEach$$inlined$unsafeTransform$1.AnonymousClass2.AnonymousClass1) 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.FlowKt__TransformKt$onEach$$inlined$unsafeTransform$1$2$1 r0 = new kotlinx.coroutines.flow.FlowKt__TransformKt$onEach$$inlined$unsafeTransform$1$2$1
+                        r0.<init>(r7)
+                    L18:
+                        java.lang.Object r7 = r0.result
+                        java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+                        int r2 = r0.label
+                        r3 = 2
+                        r4 = 1
+                        if (r2 == 0) goto L3e
+                        if (r2 == r4) goto L34
+                        if (r2 != r3) goto L2c
+                        kotlin.ResultKt.throwOnFailure(r7)
+                        goto L6a
+                    L2c:
+                        java.lang.IllegalStateException r6 = new java.lang.IllegalStateException
+                        java.lang.String r7 = "call to 'resume' before 'invoke' with coroutine"
+                        r6.<init>(r7)
+                        throw r6
+                    L34:
+                        java.lang.Object r6 = r0.L$1
+                        kotlinx.coroutines.flow.FlowCollector r6 = (kotlinx.coroutines.flow.FlowCollector) r6
+                        java.lang.Object r2 = r0.L$0
+                        kotlin.ResultKt.throwOnFailure(r7)
+                        goto L5c
+                    L3e:
+                        kotlin.ResultKt.throwOnFailure(r7)
+                        kotlinx.coroutines.flow.FlowCollector r7 = r5.$this_unsafeFlow
+                        kotlin.jvm.functions.Function2 r2 = r5.$action$inlined
+                        r0.L$0 = r6
+                        r0.L$1 = r7
+                        r0.label = r4
+                        r4 = 6
+                        kotlin.jvm.internal.InlineMarker.mark(r4)
+                        java.lang.Object r2 = r2.invoke(r6, r0)
+                        r4 = 7
+                        kotlin.jvm.internal.InlineMarker.mark(r4)
+                        if (r2 != r1) goto L5a
+                        return r1
+                    L5a:
+                        r2 = r6
+                        r6 = r7
+                    L5c:
+                        r7 = 0
+                        r0.L$0 = r7
+                        r0.L$1 = r7
+                        r0.label = r3
+                        java.lang.Object r6 = r6.emit(r2, r0)
+                        if (r6 != r1) goto L6a
+                        return r1
+                    L6a:
+                        kotlin.Unit r6 = kotlin.Unit.INSTANCE
+                        return r6
+                    */
+                    throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.FlowKt__TransformKt$onEach$$inlined$unsafeTransform$1.AnonymousClass2.emit(java.lang.Object, kotlin.coroutines.Continuation):java.lang.Object");
+                }
+            }
+
+            @Override // kotlinx.coroutines.flow.Flow
+            public Object collect(FlowCollector flowCollector, Continuation continuation) {
+                Object coroutine_suspended;
+                Object collect = Flow.this.collect(new AnonymousClass2(flowCollector, function2), continuation);
+                coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+                return collect == coroutine_suspended ? collect : Unit.INSTANCE;
+            }
+        };
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__ZipKt$combine$1$1.java

@@ -0,0 +1,68 @@
+package kotlinx.coroutines.flow;
+
+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.Function3;
+
+/* loaded from: classes5.dex */
+public final class FlowKt__ZipKt$combine$1$1 extends SuspendLambda implements Function3 {
+    public final /* synthetic */ Function3 $transform;
+    public /* synthetic */ Object L$0;
+    public /* synthetic */ Object L$1;
+    public int label;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public FlowKt__ZipKt$combine$1$1(Function3 function3, Continuation continuation) {
+        super(3, continuation);
+        this.$transform = function3;
+    }
+
+    @Override // kotlin.jvm.functions.Function3
+    public final Object invoke(FlowCollector flowCollector, Object[] objArr, Continuation continuation) {
+        FlowKt__ZipKt$combine$1$1 flowKt__ZipKt$combine$1$1 = new FlowKt__ZipKt$combine$1$1(this.$transform, continuation);
+        flowKt__ZipKt$combine$1$1.L$0 = flowCollector;
+        flowKt__ZipKt$combine$1$1.L$1 = objArr;
+        return flowKt__ZipKt$combine$1$1.invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended;
+        FlowCollector flowCollector;
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.label;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            flowCollector = (FlowCollector) this.L$0;
+            Object[] objArr = (Object[]) this.L$1;
+            Function3 function3 = this.$transform;
+            Object obj2 = objArr[0];
+            Object obj3 = objArr[1];
+            this.L$0 = flowCollector;
+            this.label = 1;
+            obj = function3.invoke(obj2, obj3, this);
+            if (obj == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                if (i != 2) {
+                    throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+                }
+                ResultKt.throwOnFailure(obj);
+                return Unit.INSTANCE;
+            }
+            flowCollector = (FlowCollector) this.L$0;
+            ResultKt.throwOnFailure(obj);
+        }
+        this.L$0 = null;
+        this.label = 2;
+        if (flowCollector.emit(obj, this) == coroutine_suspended) {
+            return coroutine_suspended;
+        }
+        return Unit.INSTANCE;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/FlowKt__ZipKt.java

@@ -0,0 +1,31 @@
+package kotlinx.coroutines.flow;
+
+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.internal.CombineKt;
+
+/* loaded from: classes5.dex */
+public abstract /* synthetic */ class FlowKt__ZipKt {
+    public static final Flow flowCombine(final Flow flow, final Flow flow2, final Function3 function3) {
+        return new Flow() { // from class: kotlinx.coroutines.flow.FlowKt__ZipKt$combine$$inlined$unsafeFlow$1
+            @Override // kotlinx.coroutines.flow.Flow
+            public Object collect(FlowCollector flowCollector, Continuation continuation) {
+                Function0 function0;
+                Object coroutine_suspended;
+                Flow[] flowArr = {Flow.this, flow2};
+                function0 = new Function0() { // from class: kotlinx.coroutines.flow.FlowKt__ZipKt$nullArrayFactory$1
+                    @Override // kotlin.jvm.functions.Function0
+                    public final Void invoke() {
+                        return null;
+                    }
+                };
+                Object combineInternal = CombineKt.combineInternal(flowCollector, flowArr, function0, new FlowKt__ZipKt$combine$1$1(function3, null), continuation);
+                coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+                return combineInternal == coroutine_suspended ? combineInternal : Unit.INSTANCE;
+            }
+        };
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/MutableSharedFlow.java

@@ -0,0 +1,15 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+
+/* loaded from: classes5.dex */
+public interface MutableSharedFlow extends SharedFlow, FlowCollector {
+    @Override // kotlinx.coroutines.flow.FlowCollector
+    Object emit(Object obj, Continuation continuation);
+
+    StateFlow getSubscriptionCount();
+
+    void resetReplayCache();
+
+    boolean tryEmit(Object obj);
+}

decompiled/sources/kotlinx/coroutines/flow/MutableStateFlow.java

@@ -0,0 +1,11 @@
+package kotlinx.coroutines.flow;
+
+/* loaded from: classes5.dex */
+public interface MutableStateFlow extends StateFlow, MutableSharedFlow {
+    boolean compareAndSet(Object obj, Object obj2);
+
+    @Override // kotlinx.coroutines.flow.StateFlow
+    Object getValue();
+
+    void setValue(Object obj);
+}

decompiled/sources/kotlinx/coroutines/flow/ReadonlySharedFlow.java

@@ -0,0 +1,28 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+import kotlinx.coroutines.Job;
+import kotlinx.coroutines.channels.BufferOverflow;
+import kotlinx.coroutines.flow.internal.FusibleFlow;
+
+/* loaded from: classes5.dex */
+public final class ReadonlySharedFlow implements SharedFlow, Flow, FusibleFlow {
+    public final /* synthetic */ SharedFlow $$delegate_0;
+    public final Job job;
+
+    @Override // kotlinx.coroutines.flow.SharedFlow, kotlinx.coroutines.flow.Flow
+    public Object collect(FlowCollector flowCollector, Continuation continuation) {
+        return this.$$delegate_0.collect(flowCollector, continuation);
+    }
+
+    public ReadonlySharedFlow(SharedFlow sharedFlow, Job job) {
+        this.job = job;
+        this.$$delegate_0 = sharedFlow;
+    }
+
+    @Override // kotlinx.coroutines.flow.internal.FusibleFlow
+    public Flow fuse(CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow) {
+        return SharedFlowKt.fuseSharedFlow(this, coroutineContext, i, bufferOverflow);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/ReadonlyStateFlow.java

@@ -0,0 +1,33 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+import kotlinx.coroutines.Job;
+import kotlinx.coroutines.channels.BufferOverflow;
+import kotlinx.coroutines.flow.internal.FusibleFlow;
+
+/* loaded from: classes5.dex */
+public final class ReadonlyStateFlow implements StateFlow, Flow, FusibleFlow {
+    public final /* synthetic */ StateFlow $$delegate_0;
+    public final Job job;
+
+    @Override // kotlinx.coroutines.flow.SharedFlow, kotlinx.coroutines.flow.Flow
+    public Object collect(FlowCollector flowCollector, Continuation continuation) {
+        return this.$$delegate_0.collect(flowCollector, continuation);
+    }
+
+    @Override // kotlinx.coroutines.flow.StateFlow
+    public Object getValue() {
+        return this.$$delegate_0.getValue();
+    }
+
+    public ReadonlyStateFlow(StateFlow stateFlow, Job job) {
+        this.job = job;
+        this.$$delegate_0 = stateFlow;
+    }
+
+    @Override // kotlinx.coroutines.flow.internal.FusibleFlow
+    public Flow fuse(CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow) {
+        return StateFlowKt.fuseStateFlow(this, coroutineContext, i, bufferOverflow);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/SafeFlow.java

@@ -0,0 +1,23 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.jvm.functions.Function2;
+
+/* loaded from: classes5.dex */
+public final class SafeFlow extends AbstractFlow {
+    public final Function2 block;
+
+    public SafeFlow(Function2 function2) {
+        this.block = function2;
+    }
+
+    @Override // kotlinx.coroutines.flow.AbstractFlow
+    public Object collectSafely(FlowCollector flowCollector, Continuation continuation) {
+        Object coroutine_suspended;
+        Object invoke = this.block.invoke(flowCollector, continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return invoke == coroutine_suspended ? invoke : Unit.INSTANCE;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/SharedFlow.java

@@ -0,0 +1,9 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+
+/* loaded from: classes5.dex */
+public interface SharedFlow extends Flow {
+    @Override // kotlinx.coroutines.flow.Flow
+    Object collect(FlowCollector flowCollector, Continuation continuation);
+}

decompiled/sources/kotlinx/coroutines/flow/SharedFlowImpl$collect$1.java

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

decompiled/sources/kotlinx/coroutines/flow/SharedFlowImpl.java

@@ -0,0 +1,572 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.Result;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.DebugProbesKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.CancellableContinuationImpl;
+import kotlinx.coroutines.CancellableContinuationKt;
+import kotlinx.coroutines.DisposableHandle;
+import kotlinx.coroutines.channels.BufferOverflow;
+import kotlinx.coroutines.flow.internal.AbstractSharedFlow;
+import kotlinx.coroutines.flow.internal.AbstractSharedFlowKt;
+import kotlinx.coroutines.flow.internal.FusibleFlow;
+
+/* loaded from: classes5.dex */
+public class SharedFlowImpl extends AbstractSharedFlow implements MutableSharedFlow, Flow, FusibleFlow {
+    public Object[] buffer;
+    public final int bufferCapacity;
+    public int bufferSize;
+    public long minCollectorIndex;
+    public final BufferOverflow onBufferOverflow;
+    public int queueSize;
+    public final int replay;
+    public long replayIndex;
+
+    public /* synthetic */ class WhenMappings {
+        public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+        static {
+            int[] iArr = new int[BufferOverflow.values().length];
+            try {
+                iArr[BufferOverflow.SUSPEND.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                iArr[BufferOverflow.DROP_LATEST.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                iArr[BufferOverflow.DROP_OLDEST.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            $EnumSwitchMapping$0 = iArr;
+        }
+    }
+
+    @Override // kotlinx.coroutines.flow.SharedFlow, kotlinx.coroutines.flow.Flow
+    public Object collect(FlowCollector flowCollector, Continuation continuation) {
+        return collect$suspendImpl(this, flowCollector, continuation);
+    }
+
+    @Override // kotlinx.coroutines.flow.MutableSharedFlow, kotlinx.coroutines.flow.FlowCollector
+    public Object emit(Object obj, Continuation continuation) {
+        return emit$suspendImpl(this, obj, continuation);
+    }
+
+    public final int getTotalSize() {
+        return this.bufferSize + this.queueSize;
+    }
+
+    public final long updateNewCollectorIndexLocked$kotlinx_coroutines_core() {
+        long j = this.replayIndex;
+        if (j < this.minCollectorIndex) {
+            this.minCollectorIndex = j;
+        }
+        return j;
+    }
+
+    public final void cancelEmitter(Emitter emitter) {
+        Object bufferAt;
+        synchronized (this) {
+            if (emitter.index < getHead()) {
+                return;
+            }
+            Object[] objArr = this.buffer;
+            Intrinsics.checkNotNull(objArr);
+            bufferAt = SharedFlowKt.getBufferAt(objArr, emitter.index);
+            if (bufferAt != emitter) {
+                return;
+            }
+            SharedFlowKt.setBufferAt(objArr, emitter.index, SharedFlowKt.NO_VALUE);
+            cleanupTailLocked();
+            Unit unit = Unit.INSTANCE;
+        }
+    }
+
+    @Override // kotlinx.coroutines.flow.MutableSharedFlow
+    public void resetReplayCache() {
+        synchronized (this) {
+            updateBufferLocked(getBufferEndIndex(), this.minCollectorIndex, getBufferEndIndex(), getQueueEndIndex());
+            Unit unit = Unit.INSTANCE;
+        }
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:3:0x0006, code lost:
+    
+        r0 = r8.slots;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final void correctCollectorIndexesOnDropOldest(long r9) {
+        /*
+            r8 = this;
+            int r0 = kotlinx.coroutines.flow.internal.AbstractSharedFlow.access$getNCollectors(r8)
+            if (r0 == 0) goto L27
+            kotlinx.coroutines.flow.internal.AbstractSharedFlowSlot[] r0 = kotlinx.coroutines.flow.internal.AbstractSharedFlow.access$getSlots(r8)
+            if (r0 == 0) goto L27
+            int r1 = r0.length
+            r2 = 0
+        Le:
+            if (r2 >= r1) goto L27
+            r3 = r0[r2]
+            if (r3 == 0) goto L24
+            kotlinx.coroutines.flow.SharedFlowSlot r3 = (kotlinx.coroutines.flow.SharedFlowSlot) r3
+            long r4 = r3.index
+            r6 = 0
+            int r6 = (r4 > r6 ? 1 : (r4 == r6 ? 0 : -1))
+            if (r6 < 0) goto L24
+            int r4 = (r4 > r9 ? 1 : (r4 == r9 ? 0 : -1))
+            if (r4 >= 0) goto L24
+            r3.index = r9
+        L24:
+            int r2 = r2 + 1
+            goto Le
+        L27:
+            r8.minCollectorIndex = r9
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.SharedFlowImpl.correctCollectorIndexesOnDropOldest(long):void");
+    }
+
+    public SharedFlowImpl(int i, int i2, BufferOverflow bufferOverflow) {
+        this.replay = i;
+        this.bufferCapacity = i2;
+        this.onBufferOverflow = bufferOverflow;
+    }
+
+    public final Object awaitValue(SharedFlowSlot sharedFlowSlot, Continuation continuation) {
+        Continuation intercepted;
+        Object coroutine_suspended;
+        Object coroutine_suspended2;
+        intercepted = IntrinsicsKt__IntrinsicsJvmKt.intercepted(continuation);
+        CancellableContinuationImpl cancellableContinuationImpl = new CancellableContinuationImpl(intercepted, 1);
+        cancellableContinuationImpl.initCancellability();
+        synchronized (this) {
+            try {
+                if (tryPeekLocked(sharedFlowSlot) >= 0) {
+                    Result.Companion companion = Result.Companion;
+                    cancellableContinuationImpl.resumeWith(Result.m4060constructorimpl(Unit.INSTANCE));
+                } else {
+                    sharedFlowSlot.cont = cancellableContinuationImpl;
+                }
+                Unit unit = Unit.INSTANCE;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        Object result = cancellableContinuationImpl.getResult();
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        if (result == coroutine_suspended) {
+            DebugProbesKt.probeCoroutineSuspended(continuation);
+        }
+        coroutine_suspended2 = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return result == coroutine_suspended2 ? result : Unit.INSTANCE;
+    }
+
+    public final Object emitSuspend(Object obj, Continuation continuation) {
+        Continuation intercepted;
+        Continuation[] continuationArr;
+        Emitter emitter;
+        Object coroutine_suspended;
+        Object coroutine_suspended2;
+        intercepted = IntrinsicsKt__IntrinsicsJvmKt.intercepted(continuation);
+        CancellableContinuationImpl cancellableContinuationImpl = new CancellableContinuationImpl(intercepted, 1);
+        cancellableContinuationImpl.initCancellability();
+        Continuation[] continuationArr2 = AbstractSharedFlowKt.EMPTY_RESUMES;
+        synchronized (this) {
+            try {
+                if (tryEmitLocked(obj)) {
+                    Result.Companion companion = Result.Companion;
+                    cancellableContinuationImpl.resumeWith(Result.m4060constructorimpl(Unit.INSTANCE));
+                    continuationArr = findSlotsToResumeLocked(continuationArr2);
+                    emitter = null;
+                } else {
+                    Emitter emitter2 = new Emitter(this, getTotalSize() + getHead(), obj, cancellableContinuationImpl);
+                    enqueueLocked(emitter2);
+                    this.queueSize++;
+                    if (this.bufferCapacity == 0) {
+                        continuationArr2 = findSlotsToResumeLocked(continuationArr2);
+                    }
+                    continuationArr = continuationArr2;
+                    emitter = emitter2;
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        if (emitter != null) {
+            CancellableContinuationKt.disposeOnCancellation(cancellableContinuationImpl, emitter);
+        }
+        for (Continuation continuation2 : continuationArr) {
+            if (continuation2 != null) {
+                Result.Companion companion2 = Result.Companion;
+                continuation2.resumeWith(Result.m4060constructorimpl(Unit.INSTANCE));
+            }
+        }
+        Object result = cancellableContinuationImpl.getResult();
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        if (result == coroutine_suspended) {
+            DebugProbesKt.probeCoroutineSuspended(continuation);
+        }
+        coroutine_suspended2 = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return result == coroutine_suspended2 ? result : Unit.INSTANCE;
+    }
+
+    public final long getHead() {
+        return Math.min(this.minCollectorIndex, this.replayIndex);
+    }
+
+    public final int getReplaySize() {
+        return (int) ((getHead() + this.bufferSize) - this.replayIndex);
+    }
+
+    public final long getBufferEndIndex() {
+        return getHead() + this.bufferSize;
+    }
+
+    public final long getQueueEndIndex() {
+        return getHead() + this.bufferSize + this.queueSize;
+    }
+
+    public final Object getLastReplayedLocked() {
+        Object bufferAt;
+        Object[] objArr = this.buffer;
+        Intrinsics.checkNotNull(objArr);
+        bufferAt = SharedFlowKt.getBufferAt(objArr, (this.replayIndex + getReplaySize()) - 1);
+        return bufferAt;
+    }
+
+    /* JADX WARN: Can't wrap try/catch for region: R(10:0|1|(2:3|(7:5|6|(3:(6:(1:(1:11)(2:41|42))(1:43)|12|13|14|15|(3:16|(3:28|29|(2:31|32)(1:33))(4:18|(1:20)|21|(2:23|24)(1:26))|27))(4:44|45|46|47)|37|38)(5:53|54|55|(2:57|(1:59))|61)|48|49|15|(3:16|(0)(0)|27)))|64|6|(0)(0)|48|49|15|(3:16|(0)(0)|27)) */
+    /* JADX WARN: Code restructure failed: missing block: B:35:0x00c2, code lost:
+    
+        r10 = move-exception;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:36:0x00c3, code lost:
+    
+        r5 = r8;
+        r8 = r10;
+     */
+    /* JADX WARN: Removed duplicated region for block: B:18:0x00c6 A[SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:28:0x00b1 A[SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:53:0x0076  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0025  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static /* synthetic */ java.lang.Object collect$suspendImpl(kotlinx.coroutines.flow.SharedFlowImpl r8, kotlinx.coroutines.flow.FlowCollector r9, kotlin.coroutines.Continuation r10) {
+        /*
+            Method dump skipped, instructions count: 224
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.SharedFlowImpl.collect$suspendImpl(kotlinx.coroutines.flow.SharedFlowImpl, kotlinx.coroutines.flow.FlowCollector, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+
+    @Override // kotlinx.coroutines.flow.MutableSharedFlow
+    public boolean tryEmit(Object obj) {
+        int i;
+        boolean z;
+        Continuation[] continuationArr = AbstractSharedFlowKt.EMPTY_RESUMES;
+        synchronized (this) {
+            if (tryEmitLocked(obj)) {
+                continuationArr = findSlotsToResumeLocked(continuationArr);
+                z = true;
+            } else {
+                z = false;
+            }
+        }
+        for (Continuation continuation : continuationArr) {
+            if (continuation != null) {
+                Result.Companion companion = Result.Companion;
+                continuation.resumeWith(Result.m4060constructorimpl(Unit.INSTANCE));
+            }
+        }
+        return z;
+    }
+
+    public static /* synthetic */ Object emit$suspendImpl(SharedFlowImpl sharedFlowImpl, Object obj, Continuation continuation) {
+        Object coroutine_suspended;
+        if (sharedFlowImpl.tryEmit(obj)) {
+            return Unit.INSTANCE;
+        }
+        Object emitSuspend = sharedFlowImpl.emitSuspend(obj, continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return emitSuspend == coroutine_suspended ? emitSuspend : Unit.INSTANCE;
+    }
+
+    public final boolean tryEmitLocked(Object obj) {
+        if (getNCollectors() == 0) {
+            return tryEmitNoCollectorsLocked(obj);
+        }
+        if (this.bufferSize >= this.bufferCapacity && this.minCollectorIndex <= this.replayIndex) {
+            int i = WhenMappings.$EnumSwitchMapping$0[this.onBufferOverflow.ordinal()];
+            if (i == 1) {
+                return false;
+            }
+            if (i == 2) {
+                return true;
+            }
+        }
+        enqueueLocked(obj);
+        int i2 = this.bufferSize + 1;
+        this.bufferSize = i2;
+        if (i2 > this.bufferCapacity) {
+            dropOldestLocked();
+        }
+        if (getReplaySize() > this.replay) {
+            updateBufferLocked(this.replayIndex + 1, this.minCollectorIndex, getBufferEndIndex(), getQueueEndIndex());
+        }
+        return true;
+    }
+
+    public final boolean tryEmitNoCollectorsLocked(Object obj) {
+        if (this.replay == 0) {
+            return true;
+        }
+        enqueueLocked(obj);
+        int i = this.bufferSize + 1;
+        this.bufferSize = i;
+        if (i > this.replay) {
+            dropOldestLocked();
+        }
+        this.minCollectorIndex = getHead() + this.bufferSize;
+        return true;
+    }
+
+    public final void dropOldestLocked() {
+        Object[] objArr = this.buffer;
+        Intrinsics.checkNotNull(objArr);
+        SharedFlowKt.setBufferAt(objArr, getHead(), null);
+        this.bufferSize--;
+        long head = getHead() + 1;
+        if (this.replayIndex < head) {
+            this.replayIndex = head;
+        }
+        if (this.minCollectorIndex < head) {
+            correctCollectorIndexesOnDropOldest(head);
+        }
+    }
+
+    public final void enqueueLocked(Object obj) {
+        int totalSize = getTotalSize();
+        Object[] objArr = this.buffer;
+        if (objArr == null) {
+            objArr = growBuffer(null, 0, 2);
+        } else if (totalSize >= objArr.length) {
+            objArr = growBuffer(objArr, totalSize, objArr.length * 2);
+        }
+        SharedFlowKt.setBufferAt(objArr, getHead() + totalSize, obj);
+    }
+
+    public final Object[] growBuffer(Object[] objArr, int i, int i2) {
+        Object bufferAt;
+        if (i2 <= 0) {
+            throw new IllegalStateException("Buffer size overflow".toString());
+        }
+        Object[] objArr2 = new Object[i2];
+        this.buffer = objArr2;
+        if (objArr == null) {
+            return objArr2;
+        }
+        long head = getHead();
+        for (int i3 = 0; i3 < i; i3++) {
+            long j = i3 + head;
+            bufferAt = SharedFlowKt.getBufferAt(objArr, j);
+            SharedFlowKt.setBufferAt(objArr2, j, bufferAt);
+        }
+        return objArr2;
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:13:0x0024, code lost:
+    
+        r4 = r21.slots;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final kotlin.coroutines.Continuation[] updateCollectorIndexLocked$kotlinx_coroutines_core(long r22) {
+        /*
+            Method dump skipped, instructions count: 269
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.SharedFlowImpl.updateCollectorIndexLocked$kotlinx_coroutines_core(long):kotlin.coroutines.Continuation[]");
+    }
+
+    public final void updateBufferLocked(long j, long j2, long j3, long j4) {
+        long min = Math.min(j2, j);
+        for (long head = getHead(); head < min; head++) {
+            Object[] objArr = this.buffer;
+            Intrinsics.checkNotNull(objArr);
+            SharedFlowKt.setBufferAt(objArr, head, null);
+        }
+        this.replayIndex = j;
+        this.minCollectorIndex = j2;
+        this.bufferSize = (int) (j3 - min);
+        this.queueSize = (int) (j4 - j3);
+    }
+
+    public final void cleanupTailLocked() {
+        Object bufferAt;
+        if (this.bufferCapacity != 0 || this.queueSize > 1) {
+            Object[] objArr = this.buffer;
+            Intrinsics.checkNotNull(objArr);
+            while (this.queueSize > 0) {
+                bufferAt = SharedFlowKt.getBufferAt(objArr, (getHead() + getTotalSize()) - 1);
+                if (bufferAt != SharedFlowKt.NO_VALUE) {
+                    return;
+                }
+                this.queueSize--;
+                SharedFlowKt.setBufferAt(objArr, getHead() + getTotalSize(), null);
+            }
+        }
+    }
+
+    public final Object tryTakeValue(SharedFlowSlot sharedFlowSlot) {
+        Object obj;
+        Continuation[] continuationArr = AbstractSharedFlowKt.EMPTY_RESUMES;
+        synchronized (this) {
+            try {
+                long tryPeekLocked = tryPeekLocked(sharedFlowSlot);
+                if (tryPeekLocked < 0) {
+                    obj = SharedFlowKt.NO_VALUE;
+                } else {
+                    long j = sharedFlowSlot.index;
+                    Object peekedValueLockedAt = getPeekedValueLockedAt(tryPeekLocked);
+                    sharedFlowSlot.index = tryPeekLocked + 1;
+                    continuationArr = updateCollectorIndexLocked$kotlinx_coroutines_core(j);
+                    obj = peekedValueLockedAt;
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        for (Continuation continuation : continuationArr) {
+            if (continuation != null) {
+                Result.Companion companion = Result.Companion;
+                continuation.resumeWith(Result.m4060constructorimpl(Unit.INSTANCE));
+            }
+        }
+        return obj;
+    }
+
+    public final long tryPeekLocked(SharedFlowSlot sharedFlowSlot) {
+        long j = sharedFlowSlot.index;
+        if (j < getBufferEndIndex()) {
+            return j;
+        }
+        if (this.bufferCapacity <= 0 && j <= getHead() && this.queueSize != 0) {
+            return j;
+        }
+        return -1L;
+    }
+
+    public final Object getPeekedValueLockedAt(long j) {
+        Object bufferAt;
+        Object[] objArr = this.buffer;
+        Intrinsics.checkNotNull(objArr);
+        bufferAt = SharedFlowKt.getBufferAt(objArr, j);
+        return bufferAt instanceof Emitter ? ((Emitter) bufferAt).value : bufferAt;
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:3:0x0007, code lost:
+    
+        r1 = r10.slots;
+     */
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r11v6, types: [java.lang.Object, java.lang.Object[]] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final kotlin.coroutines.Continuation[] findSlotsToResumeLocked(kotlin.coroutines.Continuation[] r11) {
+        /*
+            r10 = this;
+            int r0 = r11.length
+            int r1 = kotlinx.coroutines.flow.internal.AbstractSharedFlow.access$getNCollectors(r10)
+            if (r1 == 0) goto L47
+            kotlinx.coroutines.flow.internal.AbstractSharedFlowSlot[] r1 = kotlinx.coroutines.flow.internal.AbstractSharedFlow.access$getSlots(r10)
+            if (r1 == 0) goto L47
+            int r2 = r1.length
+            r3 = 0
+        Lf:
+            if (r3 >= r2) goto L47
+            r4 = r1[r3]
+            if (r4 == 0) goto L44
+            kotlinx.coroutines.flow.SharedFlowSlot r4 = (kotlinx.coroutines.flow.SharedFlowSlot) r4
+            kotlin.coroutines.Continuation r5 = r4.cont
+            if (r5 != 0) goto L1c
+            goto L44
+        L1c:
+            long r6 = r10.tryPeekLocked(r4)
+            r8 = 0
+            int r6 = (r6 > r8 ? 1 : (r6 == r8 ? 0 : -1))
+            if (r6 < 0) goto L44
+            int r6 = r11.length
+            if (r0 < r6) goto L39
+            int r6 = r11.length
+            r7 = 2
+            int r6 = r6 * r7
+            int r6 = java.lang.Math.max(r7, r6)
+            java.lang.Object[] r11 = java.util.Arrays.copyOf(r11, r6)
+            java.lang.String r6 = "copyOf(this, newSize)"
+            kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r11, r6)
+        L39:
+            r6 = r11
+            kotlin.coroutines.Continuation[] r6 = (kotlin.coroutines.Continuation[]) r6
+            int r7 = r0 + 1
+            r6[r0] = r5
+            r0 = 0
+            r4.cont = r0
+            r0 = r7
+        L44:
+            int r3 = r3 + 1
+            goto Lf
+        L47:
+            kotlin.coroutines.Continuation[] r11 = (kotlin.coroutines.Continuation[]) r11
+            return r11
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.SharedFlowImpl.findSlotsToResumeLocked(kotlin.coroutines.Continuation[]):kotlin.coroutines.Continuation[]");
+    }
+
+    @Override // kotlinx.coroutines.flow.internal.AbstractSharedFlow
+    public SharedFlowSlot createSlot() {
+        return new SharedFlowSlot();
+    }
+
+    @Override // kotlinx.coroutines.flow.internal.AbstractSharedFlow
+    public SharedFlowSlot[] createSlotArray(int i) {
+        return new SharedFlowSlot[i];
+    }
+
+    @Override // kotlinx.coroutines.flow.internal.FusibleFlow
+    public Flow fuse(CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow) {
+        return SharedFlowKt.fuseSharedFlow(this, coroutineContext, i, bufferOverflow);
+    }
+
+    public static final class Emitter implements DisposableHandle {
+        public final Continuation cont;
+        public final SharedFlowImpl flow;
+        public long index;
+        public final Object value;
+
+        public Emitter(SharedFlowImpl sharedFlowImpl, long j, Object obj, Continuation continuation) {
+            this.flow = sharedFlowImpl;
+            this.index = j;
+            this.value = obj;
+            this.cont = continuation;
+        }
+
+        @Override // kotlinx.coroutines.DisposableHandle
+        public void dispose() {
+            this.flow.cancelEmitter(this);
+        }
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/SharedFlowKt.java

@@ -0,0 +1,53 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.CoroutineContext;
+import kotlinx.coroutines.channels.BufferOverflow;
+import kotlinx.coroutines.flow.internal.ChannelFlowOperatorImpl;
+import kotlinx.coroutines.internal.Symbol;
+
+/* loaded from: classes5.dex */
+public abstract class SharedFlowKt {
+    public static final Symbol NO_VALUE = new Symbol("NO_VALUE");
+
+    public static /* synthetic */ MutableSharedFlow MutableSharedFlow$default(int i, int i2, BufferOverflow bufferOverflow, int i3, Object obj) {
+        if ((i3 & 1) != 0) {
+            i = 0;
+        }
+        if ((i3 & 2) != 0) {
+            i2 = 0;
+        }
+        if ((i3 & 4) != 0) {
+            bufferOverflow = BufferOverflow.SUSPEND;
+        }
+        return MutableSharedFlow(i, i2, bufferOverflow);
+    }
+
+    public static final MutableSharedFlow MutableSharedFlow(int i, int i2, BufferOverflow bufferOverflow) {
+        if (i < 0) {
+            throw new IllegalArgumentException(("replay cannot be negative, but was " + i).toString());
+        }
+        if (i2 < 0) {
+            throw new IllegalArgumentException(("extraBufferCapacity cannot be negative, but was " + i2).toString());
+        }
+        if (i <= 0 && i2 <= 0 && bufferOverflow != BufferOverflow.SUSPEND) {
+            throw new IllegalArgumentException(("replay or extraBufferCapacity must be positive with non-default onBufferOverflow strategy " + bufferOverflow).toString());
+        }
+        int i3 = i2 + i;
+        if (i3 < 0) {
+            i3 = Integer.MAX_VALUE;
+        }
+        return new SharedFlowImpl(i, i3, bufferOverflow);
+    }
+
+    public static final Object getBufferAt(Object[] objArr, long j) {
+        return objArr[((int) j) & (objArr.length - 1)];
+    }
+
+    public static final void setBufferAt(Object[] objArr, long j, Object obj) {
+        objArr[((int) j) & (objArr.length - 1)] = obj;
+    }
+
+    public static final Flow fuseSharedFlow(SharedFlow sharedFlow, CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow) {
+        return ((i == 0 || i == -3) && bufferOverflow == BufferOverflow.SUSPEND) ? sharedFlow : new ChannelFlowOperatorImpl(sharedFlow, coroutineContext, i, bufferOverflow);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/SharedFlowSlot.java

@@ -0,0 +1,27 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlinx.coroutines.flow.internal.AbstractSharedFlowSlot;
+
+/* loaded from: classes5.dex */
+public final class SharedFlowSlot extends AbstractSharedFlowSlot {
+    public Continuation cont;
+    public long index = -1;
+
+    @Override // kotlinx.coroutines.flow.internal.AbstractSharedFlowSlot
+    public boolean allocateLocked(SharedFlowImpl sharedFlowImpl) {
+        if (this.index >= 0) {
+            return false;
+        }
+        this.index = sharedFlowImpl.updateNewCollectorIndexLocked$kotlinx_coroutines_core();
+        return true;
+    }
+
+    @Override // kotlinx.coroutines.flow.internal.AbstractSharedFlowSlot
+    public Continuation[] freeLocked(SharedFlowImpl sharedFlowImpl) {
+        long j = this.index;
+        this.index = -1L;
+        this.cont = null;
+        return sharedFlowImpl.updateCollectorIndexLocked$kotlinx_coroutines_core(j);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/SharingCommand.java

@@ -0,0 +1,8 @@
+package kotlinx.coroutines.flow;
+
+/* loaded from: classes5.dex */
+public enum SharingCommand {
+    START,
+    STOP,
+    STOP_AND_RESET_REPLAY_CACHE
+}

decompiled/sources/kotlinx/coroutines/flow/SharingConfig.java

@@ -0,0 +1,19 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.CoroutineContext;
+import kotlinx.coroutines.channels.BufferOverflow;
+
+/* loaded from: classes5.dex */
+public final class SharingConfig {
+    public final CoroutineContext context;
+    public final int extraBufferCapacity;
+    public final BufferOverflow onBufferOverflow;
+    public final Flow upstream;
+
+    public SharingConfig(Flow flow, int i, BufferOverflow bufferOverflow, CoroutineContext coroutineContext) {
+        this.upstream = flow;
+        this.extraBufferCapacity = i;
+        this.onBufferOverflow = bufferOverflow;
+        this.context = coroutineContext;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/SharingStarted.java

@@ -0,0 +1,22 @@
+package kotlinx.coroutines.flow;
+
+/* loaded from: classes5.dex */
+public interface SharingStarted {
+    public static final Companion Companion = Companion.$$INSTANCE;
+
+    public static final class Companion {
+        public static final /* synthetic */ Companion $$INSTANCE = new Companion();
+        public static final SharingStarted Eagerly = new StartedEagerly();
+        public static final SharingStarted Lazily = new StartedLazily();
+
+        public final SharingStarted getEagerly() {
+            return Eagerly;
+        }
+
+        public final SharingStarted getLazily() {
+            return Lazily;
+        }
+    }
+
+    Flow command(StateFlow stateFlow);
+}

decompiled/sources/kotlinx/coroutines/flow/StartedEagerly.java

@@ -0,0 +1,13 @@
+package kotlinx.coroutines.flow;
+
+/* loaded from: classes5.dex */
+public final class StartedEagerly implements SharingStarted {
+    public String toString() {
+        return "SharingStarted.Eagerly";
+    }
+
+    @Override // kotlinx.coroutines.flow.SharingStarted
+    public Flow command(StateFlow stateFlow) {
+        return FlowKt.flowOf(SharingCommand.START);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/StartedLazily$command$1$1$emit$1.java

@@ -0,0 +1,25 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlinx.coroutines.flow.StartedLazily$command$1;
+
+/* loaded from: classes5.dex */
+public final class StartedLazily$command$1$1$emit$1 extends ContinuationImpl {
+    public int label;
+    public /* synthetic */ Object result;
+    public final /* synthetic */ StartedLazily$command$1.AnonymousClass1 this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public StartedLazily$command$1$1$emit$1(StartedLazily$command$1.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(0, this);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/StartedLazily$command$1.java

@@ -0,0 +1,135 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.KotlinNothingValueException;
+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.internal.Ref;
+
+/* loaded from: classes5.dex */
+public final class StartedLazily$command$1 extends SuspendLambda implements Function2 {
+    public final /* synthetic */ StateFlow $subscriptionCount;
+    public /* synthetic */ Object L$0;
+    public int label;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public StartedLazily$command$1(StateFlow stateFlow, Continuation continuation) {
+        super(2, continuation);
+        this.$subscriptionCount = stateFlow;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        StartedLazily$command$1 startedLazily$command$1 = new StartedLazily$command$1(this.$subscriptionCount, continuation);
+        startedLazily$command$1.L$0 = obj;
+        return startedLazily$command$1;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(FlowCollector flowCollector, Continuation continuation) {
+        return ((StartedLazily$command$1) 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;
+            Ref.BooleanRef booleanRef = new Ref.BooleanRef();
+            StateFlow stateFlow = this.$subscriptionCount;
+            AnonymousClass1 anonymousClass1 = new AnonymousClass1(booleanRef, flowCollector);
+            this.label = 1;
+            if (stateFlow.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);
+        }
+        throw new KotlinNothingValueException();
+    }
+
+    /* renamed from: kotlinx.coroutines.flow.StartedLazily$command$1$1, reason: invalid class name */
+    public static final class AnonymousClass1 implements FlowCollector {
+        public final /* synthetic */ FlowCollector $$this$flow;
+        public final /* synthetic */ Ref.BooleanRef $started;
+
+        public AnonymousClass1(Ref.BooleanRef booleanRef, FlowCollector flowCollector) {
+            this.$started = booleanRef;
+            this.$$this$flow = flowCollector;
+        }
+
+        /* JADX WARN: Removed duplicated region for block: B:15:0x0031  */
+        /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+        /*
+            Code decompiled incorrectly, please refer to instructions dump.
+            To view partially-correct add '--show-bad-code' argument
+        */
+        public final java.lang.Object emit(int r5, kotlin.coroutines.Continuation r6) {
+            /*
+                r4 = this;
+                boolean r0 = r6 instanceof kotlinx.coroutines.flow.StartedLazily$command$1$1$emit$1
+                if (r0 == 0) goto L13
+                r0 = r6
+                kotlinx.coroutines.flow.StartedLazily$command$1$1$emit$1 r0 = (kotlinx.coroutines.flow.StartedLazily$command$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.StartedLazily$command$1$1$emit$1 r0 = new kotlinx.coroutines.flow.StartedLazily$command$1$1$emit$1
+                r0.<init>(r4, r6)
+            L18:
+                java.lang.Object r6 = r0.result
+                java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+                int r2 = r0.label
+                r3 = 1
+                if (r2 == 0) goto L31
+                if (r2 != r3) goto L29
+                kotlin.ResultKt.throwOnFailure(r6)
+                goto L4b
+            L29:
+                java.lang.IllegalStateException r5 = new java.lang.IllegalStateException
+                java.lang.String r6 = "call to 'resume' before 'invoke' with coroutine"
+                r5.<init>(r6)
+                throw r5
+            L31:
+                kotlin.ResultKt.throwOnFailure(r6)
+                if (r5 <= 0) goto L4e
+                kotlin.jvm.internal.Ref$BooleanRef r5 = r4.$started
+                boolean r6 = r5.element
+                if (r6 != 0) goto L4e
+                r5.element = r3
+                kotlinx.coroutines.flow.FlowCollector r5 = r4.$$this$flow
+                kotlinx.coroutines.flow.SharingCommand r6 = kotlinx.coroutines.flow.SharingCommand.START
+                r0.label = r3
+                java.lang.Object r5 = r5.emit(r6, r0)
+                if (r5 != r1) goto L4b
+                return r1
+            L4b:
+                kotlin.Unit r5 = kotlin.Unit.INSTANCE
+                return r5
+            L4e:
+                kotlin.Unit r5 = kotlin.Unit.INSTANCE
+                return r5
+            */
+            throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.StartedLazily$command$1.AnonymousClass1.emit(int, kotlin.coroutines.Continuation):java.lang.Object");
+        }
+
+        @Override // kotlinx.coroutines.flow.FlowCollector
+        public /* bridge */ /* synthetic */ Object emit(Object obj, Continuation continuation) {
+            return emit(((Number) obj).intValue(), continuation);
+        }
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/StartedLazily.java

@@ -0,0 +1,13 @@
+package kotlinx.coroutines.flow;
+
+/* loaded from: classes5.dex */
+public final class StartedLazily implements SharingStarted {
+    public String toString() {
+        return "SharingStarted.Lazily";
+    }
+
+    @Override // kotlinx.coroutines.flow.SharingStarted
+    public Flow command(StateFlow stateFlow) {
+        return FlowKt.flow(new StartedLazily$command$1(stateFlow, null));
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/StateFlow.java

@@ -0,0 +1,6 @@
+package kotlinx.coroutines.flow;
+
+/* loaded from: classes5.dex */
+public interface StateFlow extends SharedFlow {
+    Object getValue();
+}

decompiled/sources/kotlinx/coroutines/flow/StateFlowImpl$collect$1.java

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

decompiled/sources/kotlinx/coroutines/flow/StateFlowImpl.java

@@ -0,0 +1,176 @@
+package kotlinx.coroutines.flow;
+
+import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.channels.BufferOverflow;
+import kotlinx.coroutines.flow.internal.AbstractSharedFlow;
+import kotlinx.coroutines.flow.internal.AbstractSharedFlowSlot;
+import kotlinx.coroutines.flow.internal.FusibleFlow;
+import kotlinx.coroutines.flow.internal.NullSurrogateKt;
+import kotlinx.coroutines.internal.Symbol;
+
+/* loaded from: classes5.dex */
+public final class StateFlowImpl extends AbstractSharedFlow implements MutableStateFlow, Flow, FusibleFlow {
+    public static final AtomicReferenceFieldUpdater _state$FU = AtomicReferenceFieldUpdater.newUpdater(StateFlowImpl.class, Object.class, "_state");
+    private volatile Object _state;
+    public int sequence;
+
+    public final boolean updateState(Object obj, Object obj2) {
+        int i;
+        AbstractSharedFlowSlot[] slots;
+        synchronized (this) {
+            AtomicReferenceFieldUpdater atomicReferenceFieldUpdater = _state$FU;
+            Object obj3 = atomicReferenceFieldUpdater.get(this);
+            if (obj != null && !Intrinsics.areEqual(obj3, obj)) {
+                return false;
+            }
+            if (Intrinsics.areEqual(obj3, obj2)) {
+                return true;
+            }
+            atomicReferenceFieldUpdater.set(this, obj2);
+            int i2 = this.sequence;
+            if ((i2 & 1) != 0) {
+                this.sequence = i2 + 2;
+                return true;
+            }
+            int i3 = i2 + 1;
+            this.sequence = i3;
+            AbstractSharedFlowSlot[] slots2 = getSlots();
+            Unit unit = Unit.INSTANCE;
+            while (true) {
+                StateFlowSlot[] stateFlowSlotArr = (StateFlowSlot[]) slots2;
+                if (stateFlowSlotArr != null) {
+                    for (StateFlowSlot stateFlowSlot : stateFlowSlotArr) {
+                        if (stateFlowSlot != null) {
+                            stateFlowSlot.makePending();
+                        }
+                    }
+                }
+                synchronized (this) {
+                    i = this.sequence;
+                    if (i == i3) {
+                        this.sequence = i3 + 1;
+                        return true;
+                    }
+                    slots = getSlots();
+                    Unit unit2 = Unit.INSTANCE;
+                }
+                slots2 = slots;
+                i3 = i;
+            }
+        }
+    }
+
+    public StateFlowImpl(Object obj) {
+        this._state = obj;
+    }
+
+    @Override // kotlinx.coroutines.flow.MutableStateFlow, kotlinx.coroutines.flow.StateFlow
+    public Object getValue() {
+        Symbol symbol = NullSurrogateKt.NULL;
+        Object obj = _state$FU.get(this);
+        if (obj == symbol) {
+            return null;
+        }
+        return obj;
+    }
+
+    @Override // kotlinx.coroutines.flow.MutableStateFlow
+    public void setValue(Object obj) {
+        if (obj == null) {
+            obj = NullSurrogateKt.NULL;
+        }
+        updateState(null, obj);
+    }
+
+    @Override // kotlinx.coroutines.flow.MutableStateFlow
+    public boolean compareAndSet(Object obj, Object obj2) {
+        if (obj == null) {
+            obj = NullSurrogateKt.NULL;
+        }
+        if (obj2 == null) {
+            obj2 = NullSurrogateKt.NULL;
+        }
+        return updateState(obj, obj2);
+    }
+
+    @Override // kotlinx.coroutines.flow.MutableSharedFlow
+    public boolean tryEmit(Object obj) {
+        setValue(obj);
+        return true;
+    }
+
+    @Override // kotlinx.coroutines.flow.MutableSharedFlow, kotlinx.coroutines.flow.FlowCollector
+    public Object emit(Object obj, Continuation continuation) {
+        setValue(obj);
+        return Unit.INSTANCE;
+    }
+
+    @Override // kotlinx.coroutines.flow.MutableSharedFlow
+    public void resetReplayCache() {
+        throw new UnsupportedOperationException("MutableStateFlow.resetReplayCache is not supported");
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:19:0x00bc, code lost:
+    
+        if (kotlin.jvm.internal.Intrinsics.areEqual(r11, r12) == false) goto L42;
+     */
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Removed duplicated region for block: B:16:0x00b3 A[Catch: all -> 0x0043, TryCatch #0 {all -> 0x0043, blocks: (B:13:0x003e, B:14:0x00ab, B:16:0x00b3, B:18:0x00b8, B:20:0x00d9, B:22:0x00df, B:26:0x00be, B:29:0x00c5, B:38:0x0060, B:40:0x0073, B:41:0x009c), top: B:7:0x0024 }] */
+    /* JADX WARN: Removed duplicated region for block: B:18:0x00b8 A[Catch: all -> 0x0043, TryCatch #0 {all -> 0x0043, blocks: (B:13:0x003e, B:14:0x00ab, B:16:0x00b3, B:18:0x00b8, B:20:0x00d9, B:22:0x00df, B:26:0x00be, B:29:0x00c5, B:38:0x0060, B:40:0x0073, B:41:0x009c), top: B:7:0x0024 }] */
+    /* JADX WARN: Removed duplicated region for block: B:22:0x00df A[Catch: all -> 0x0043, TRY_LEAVE, TryCatch #0 {all -> 0x0043, blocks: (B:13:0x003e, B:14:0x00ab, B:16:0x00b3, B:18:0x00b8, B:20:0x00d9, B:22:0x00df, B:26:0x00be, B:29:0x00c5, B:38:0x0060, B:40:0x0073, B:41:0x009c), top: B:7:0x0024 }] */
+    /* JADX WARN: Removed duplicated region for block: B:28:0x00c2  */
+    /* JADX WARN: Removed duplicated region for block: B:31:0x00d7 A[RETURN] */
+    /* JADX WARN: Removed duplicated region for block: B:32:0x00d8  */
+    /* JADX WARN: Removed duplicated region for block: B:33:0x00c4  */
+    /* JADX WARN: Removed duplicated region for block: B:42:0x0077  */
+    /* JADX WARN: Removed duplicated region for block: B:9:0x0026  */
+    /* JADX WARN: Type inference failed for: r6v0 */
+    /* JADX WARN: Type inference failed for: r6v1 */
+    /* JADX WARN: Type inference failed for: r6v14 */
+    /* JADX WARN: Type inference failed for: r6v15 */
+    /* JADX WARN: Type inference failed for: r6v16 */
+    /* JADX WARN: Type inference failed for: r6v17 */
+    /* JADX WARN: Type inference failed for: r6v2, types: [kotlinx.coroutines.flow.internal.AbstractSharedFlowSlot] */
+    /* JADX WARN: Type inference failed for: r6v3 */
+    /* JADX WARN: Type inference failed for: r6v7, types: [java.lang.Object] */
+    /* JADX WARN: Type inference failed for: r8v1, types: [kotlinx.coroutines.flow.internal.AbstractSharedFlow] */
+    /* JADX WARN: Type inference failed for: r8v13 */
+    /* JADX WARN: Type inference failed for: r8v14 */
+    /* JADX WARN: Type inference failed for: r8v15 */
+    /* JADX WARN: Type inference failed for: r8v16 */
+    /* JADX WARN: Type inference failed for: r8v2 */
+    /* JADX WARN: Type inference failed for: r8v6, types: [java.lang.Object] */
+    /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:21:0x00dd -> B:14:0x00ab). Please report as a decompilation issue!!! */
+    /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:23:0x00ef -> B:14:0x00ab). Please report as a decompilation issue!!! */
+    @Override // kotlinx.coroutines.flow.SharedFlow, kotlinx.coroutines.flow.Flow
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public java.lang.Object collect(kotlinx.coroutines.flow.FlowCollector r11, kotlin.coroutines.Continuation r12) {
+        /*
+            Method dump skipped, instructions count: 246
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.StateFlowImpl.collect(kotlinx.coroutines.flow.FlowCollector, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+
+    @Override // kotlinx.coroutines.flow.internal.AbstractSharedFlow
+    public StateFlowSlot createSlot() {
+        return new StateFlowSlot();
+    }
+
+    @Override // kotlinx.coroutines.flow.internal.AbstractSharedFlow
+    public StateFlowSlot[] createSlotArray(int i) {
+        return new StateFlowSlot[i];
+    }
+
+    @Override // kotlinx.coroutines.flow.internal.FusibleFlow
+    public Flow fuse(CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow) {
+        return StateFlowKt.fuseStateFlow(this, coroutineContext, i, bufferOverflow);
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/StateFlowKt.java

@@ -0,0 +1,23 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.CoroutineContext;
+import kotlinx.coroutines.channels.BufferOverflow;
+import kotlinx.coroutines.flow.internal.NullSurrogateKt;
+import kotlinx.coroutines.internal.Symbol;
+
+/* loaded from: classes5.dex */
+public abstract class StateFlowKt {
+    public static final Symbol NONE = new Symbol("NONE");
+    public static final Symbol PENDING = new Symbol("PENDING");
+
+    public static final MutableStateFlow MutableStateFlow(Object obj) {
+        if (obj == null) {
+            obj = NullSurrogateKt.NULL;
+        }
+        return new StateFlowImpl(obj);
+    }
+
+    public static final Flow fuseStateFlow(StateFlow stateFlow, CoroutineContext coroutineContext, int i, BufferOverflow bufferOverflow) {
+        return (((i < 0 || i >= 2) && i != -2) || bufferOverflow != BufferOverflow.DROP_OLDEST) ? SharedFlowKt.fuseSharedFlow(stateFlow, coroutineContext, i, bufferOverflow) : stateFlow;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/StateFlowSlot.java

@@ -0,0 +1,107 @@
+package kotlinx.coroutines.flow;
+
+import androidx.concurrent.futures.AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0;
+import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
+import kotlin.Result;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.DebugProbesKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.CancellableContinuationImpl;
+import kotlinx.coroutines.flow.internal.AbstractSharedFlowKt;
+import kotlinx.coroutines.flow.internal.AbstractSharedFlowSlot;
+import kotlinx.coroutines.internal.Symbol;
+
+/* loaded from: classes5.dex */
+public final class StateFlowSlot extends AbstractSharedFlowSlot {
+    public static final AtomicReferenceFieldUpdater _state$FU = AtomicReferenceFieldUpdater.newUpdater(StateFlowSlot.class, Object.class, "_state");
+    private volatile Object _state;
+
+    @Override // kotlinx.coroutines.flow.internal.AbstractSharedFlowSlot
+    public boolean allocateLocked(StateFlowImpl stateFlowImpl) {
+        Symbol symbol;
+        AtomicReferenceFieldUpdater atomicReferenceFieldUpdater = _state$FU;
+        if (atomicReferenceFieldUpdater.get(this) != null) {
+            return false;
+        }
+        symbol = StateFlowKt.NONE;
+        atomicReferenceFieldUpdater.set(this, symbol);
+        return true;
+    }
+
+    @Override // kotlinx.coroutines.flow.internal.AbstractSharedFlowSlot
+    public Continuation[] freeLocked(StateFlowImpl stateFlowImpl) {
+        _state$FU.set(this, null);
+        return AbstractSharedFlowKt.EMPTY_RESUMES;
+    }
+
+    public final void makePending() {
+        Symbol symbol;
+        Symbol symbol2;
+        Symbol symbol3;
+        Symbol symbol4;
+        AtomicReferenceFieldUpdater atomicReferenceFieldUpdater = _state$FU;
+        while (true) {
+            Object obj = atomicReferenceFieldUpdater.get(this);
+            if (obj == null) {
+                return;
+            }
+            symbol = StateFlowKt.PENDING;
+            if (obj == symbol) {
+                return;
+            }
+            symbol2 = StateFlowKt.NONE;
+            if (obj == symbol2) {
+                AtomicReferenceFieldUpdater atomicReferenceFieldUpdater2 = _state$FU;
+                symbol3 = StateFlowKt.PENDING;
+                if (AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0.m(atomicReferenceFieldUpdater2, this, obj, symbol3)) {
+                    return;
+                }
+            } else {
+                AtomicReferenceFieldUpdater atomicReferenceFieldUpdater3 = _state$FU;
+                symbol4 = StateFlowKt.NONE;
+                if (AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0.m(atomicReferenceFieldUpdater3, this, obj, symbol4)) {
+                    Result.Companion companion = Result.Companion;
+                    ((CancellableContinuationImpl) obj).resumeWith(Result.m4060constructorimpl(Unit.INSTANCE));
+                    return;
+                }
+            }
+        }
+    }
+
+    public final boolean takePending() {
+        Symbol symbol;
+        Symbol symbol2;
+        AtomicReferenceFieldUpdater atomicReferenceFieldUpdater = _state$FU;
+        symbol = StateFlowKt.NONE;
+        Object andSet = atomicReferenceFieldUpdater.getAndSet(this, symbol);
+        Intrinsics.checkNotNull(andSet);
+        symbol2 = StateFlowKt.PENDING;
+        return andSet == symbol2;
+    }
+
+    public final Object awaitPending(Continuation continuation) {
+        Continuation intercepted;
+        Symbol symbol;
+        Object coroutine_suspended;
+        Object coroutine_suspended2;
+        intercepted = IntrinsicsKt__IntrinsicsJvmKt.intercepted(continuation);
+        CancellableContinuationImpl cancellableContinuationImpl = new CancellableContinuationImpl(intercepted, 1);
+        cancellableContinuationImpl.initCancellability();
+        AtomicReferenceFieldUpdater atomicReferenceFieldUpdater = _state$FU;
+        symbol = StateFlowKt.NONE;
+        if (!AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0.m(atomicReferenceFieldUpdater, this, symbol, cancellableContinuationImpl)) {
+            Result.Companion companion = Result.Companion;
+            cancellableContinuationImpl.resumeWith(Result.m4060constructorimpl(Unit.INSTANCE));
+        }
+        Object result = cancellableContinuationImpl.getResult();
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        if (result == coroutine_suspended) {
+            DebugProbesKt.probeCoroutineSuspended(continuation);
+        }
+        coroutine_suspended2 = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return result == coroutine_suspended2 ? result : Unit.INSTANCE;
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/SubscribedFlowCollector$onSubscription$1.java

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

decompiled/sources/kotlinx/coroutines/flow/SubscribedFlowCollector.java

@@ -0,0 +1,116 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+import kotlin.jvm.functions.Function2;
+
+/* loaded from: classes5.dex */
+public final class SubscribedFlowCollector implements FlowCollector {
+    public final Function2 action;
+    public final FlowCollector collector;
+
+    @Override // kotlinx.coroutines.flow.FlowCollector
+    public Object emit(Object obj, Continuation continuation) {
+        return this.collector.emit(obj, continuation);
+    }
+
+    public SubscribedFlowCollector(FlowCollector flowCollector, Function2 function2) {
+        this.collector = flowCollector;
+        this.action = function2;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Removed duplicated region for block: B:21:0x0069  */
+    /* JADX WARN: Removed duplicated region for block: B:24:0x007c  */
+    /* JADX WARN: Removed duplicated region for block: B:27:0x0042  */
+    /* JADX WARN: Removed duplicated region for block: B:9:0x0024  */
+    /* JADX WARN: Type inference failed for: r2v0, types: [int] */
+    /* JADX WARN: Type inference failed for: r2v1, types: [kotlinx.coroutines.flow.internal.SafeCollector] */
+    /* JADX WARN: Type inference failed for: r2v4, types: [boolean] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final java.lang.Object onSubscription(kotlin.coroutines.Continuation r7) {
+        /*
+            r6 = this;
+            boolean r0 = r7 instanceof kotlinx.coroutines.flow.SubscribedFlowCollector$onSubscription$1
+            if (r0 == 0) goto L13
+            r0 = r7
+            kotlinx.coroutines.flow.SubscribedFlowCollector$onSubscription$1 r0 = (kotlinx.coroutines.flow.SubscribedFlowCollector$onSubscription$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.SubscribedFlowCollector$onSubscription$1 r0 = new kotlinx.coroutines.flow.SubscribedFlowCollector$onSubscription$1
+            r0.<init>(r6, r7)
+        L18:
+            java.lang.Object r7 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 2
+            r4 = 1
+            if (r2 == 0) goto L42
+            if (r2 == r4) goto L34
+            if (r2 != r3) goto L2c
+            kotlin.ResultKt.throwOnFailure(r7)
+            goto L79
+        L2c:
+            java.lang.IllegalStateException r7 = new java.lang.IllegalStateException
+            java.lang.String r0 = "call to 'resume' before 'invoke' with coroutine"
+            r7.<init>(r0)
+            throw r7
+        L34:
+            java.lang.Object r2 = r0.L$1
+            kotlinx.coroutines.flow.internal.SafeCollector r2 = (kotlinx.coroutines.flow.internal.SafeCollector) r2
+            java.lang.Object r4 = r0.L$0
+            kotlinx.coroutines.flow.SubscribedFlowCollector r4 = (kotlinx.coroutines.flow.SubscribedFlowCollector) r4
+            kotlin.ResultKt.throwOnFailure(r7)     // Catch: java.lang.Throwable -> L40
+            goto L60
+        L40:
+            r7 = move-exception
+            goto L7f
+        L42:
+            kotlin.ResultKt.throwOnFailure(r7)
+            kotlinx.coroutines.flow.internal.SafeCollector r2 = new kotlinx.coroutines.flow.internal.SafeCollector
+            kotlinx.coroutines.flow.FlowCollector r7 = r6.collector
+            kotlin.coroutines.CoroutineContext r5 = r0.getContext()
+            r2.<init>(r7, r5)
+            kotlin.jvm.functions.Function2 r7 = r6.action     // Catch: java.lang.Throwable -> L40
+            r0.L$0 = r6     // Catch: java.lang.Throwable -> L40
+            r0.L$1 = r2     // Catch: java.lang.Throwable -> L40
+            r0.label = r4     // Catch: java.lang.Throwable -> L40
+            java.lang.Object r7 = r7.invoke(r2, r0)     // Catch: java.lang.Throwable -> L40
+            if (r7 != r1) goto L5f
+            return r1
+        L5f:
+            r4 = r6
+        L60:
+            r2.releaseIntercepted()
+            kotlinx.coroutines.flow.FlowCollector r7 = r4.collector
+            boolean r2 = r7 instanceof kotlinx.coroutines.flow.SubscribedFlowCollector
+            if (r2 == 0) goto L7c
+            kotlinx.coroutines.flow.SubscribedFlowCollector r7 = (kotlinx.coroutines.flow.SubscribedFlowCollector) r7
+            r2 = 0
+            r0.L$0 = r2
+            r0.L$1 = r2
+            r0.label = r3
+            java.lang.Object r7 = r7.onSubscription(r0)
+            if (r7 != r1) goto L79
+            return r1
+        L79:
+            kotlin.Unit r7 = kotlin.Unit.INSTANCE
+            return r7
+        L7c:
+            kotlin.Unit r7 = kotlin.Unit.INSTANCE
+            return r7
+        L7f:
+            r2.releaseIntercepted()
+            throw r7
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.SubscribedFlowCollector.onSubscription(kotlin.coroutines.Continuation):java.lang.Object");
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/SubscribedSharedFlow$collect$1.java

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

decompiled/sources/kotlinx/coroutines/flow/SubscribedSharedFlow.java

@@ -0,0 +1,70 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.jvm.functions.Function2;
+
+/* loaded from: classes5.dex */
+public final class SubscribedSharedFlow implements SharedFlow {
+    public final Function2 action;
+    public final SharedFlow sharedFlow;
+
+    public SubscribedSharedFlow(SharedFlow sharedFlow, Function2 function2) {
+        this.sharedFlow = sharedFlow;
+        this.action = function2;
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:15:0x0031  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+    @Override // kotlinx.coroutines.flow.SharedFlow, kotlinx.coroutines.flow.Flow
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public java.lang.Object collect(kotlinx.coroutines.flow.FlowCollector r6, kotlin.coroutines.Continuation r7) {
+        /*
+            r5 = this;
+            boolean r0 = r7 instanceof kotlinx.coroutines.flow.SubscribedSharedFlow$collect$1
+            if (r0 == 0) goto L13
+            r0 = r7
+            kotlinx.coroutines.flow.SubscribedSharedFlow$collect$1 r0 = (kotlinx.coroutines.flow.SubscribedSharedFlow$collect$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.SubscribedSharedFlow$collect$1 r0 = new kotlinx.coroutines.flow.SubscribedSharedFlow$collect$1
+            r0.<init>(r5, r7)
+        L18:
+            java.lang.Object r7 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 1
+            if (r2 == 0) goto L31
+            if (r2 == r3) goto L2d
+            java.lang.IllegalStateException r6 = new java.lang.IllegalStateException
+            java.lang.String r7 = "call to 'resume' before 'invoke' with coroutine"
+            r6.<init>(r7)
+            throw r6
+        L2d:
+            kotlin.ResultKt.throwOnFailure(r7)
+            goto L46
+        L31:
+            kotlin.ResultKt.throwOnFailure(r7)
+            kotlinx.coroutines.flow.SharedFlow r7 = r5.sharedFlow
+            kotlinx.coroutines.flow.SubscribedFlowCollector r2 = new kotlinx.coroutines.flow.SubscribedFlowCollector
+            kotlin.jvm.functions.Function2 r4 = r5.action
+            r2.<init>(r6, r4)
+            r0.label = r3
+            java.lang.Object r6 = r7.collect(r2, r0)
+            if (r6 != r1) goto L46
+            return r1
+        L46:
+            kotlin.KotlinNothingValueException r6 = new kotlin.KotlinNothingValueException
+            r6.<init>()
+            throw r6
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlinx.coroutines.flow.SubscribedSharedFlow.collect(kotlinx.coroutines.flow.FlowCollector, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+}

decompiled/sources/kotlinx/coroutines/flow/ThrowingCollector.java

@@ -0,0 +1,17 @@
+package kotlinx.coroutines.flow;
+
+import kotlin.coroutines.Continuation;
+
+/* loaded from: classes5.dex */
+public final class ThrowingCollector implements FlowCollector {
+    public final Throwable e;
+
+    public ThrowingCollector(Throwable th) {
+        this.e = th;
+    }
+
+    @Override // kotlinx.coroutines.flow.FlowCollector
+    public Object emit(Object obj, Continuation continuation) {
+        throw this.e;
+    }
+}

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) {
+    }
+}