Add decompiled APK source code (JADX)

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

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

decompiled/sources/kotlin/sequences/ConstrainedOnceSequence.java

@@ -0,0 +1,24 @@
+package kotlin.sequences;
+
+import java.util.Iterator;
+import java.util.concurrent.atomic.AtomicReference;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class ConstrainedOnceSequence implements Sequence {
+    public final AtomicReference sequenceRef;
+
+    public ConstrainedOnceSequence(Sequence sequence) {
+        Intrinsics.checkNotNullParameter(sequence, "sequence");
+        this.sequenceRef = new AtomicReference(sequence);
+    }
+
+    @Override // kotlin.sequences.Sequence
+    public Iterator iterator() {
+        Sequence sequence = (Sequence) this.sequenceRef.getAndSet(null);
+        if (sequence == null) {
+            throw new IllegalStateException("This sequence can be consumed only once.");
+        }
+        return sequence.iterator();
+    }
+}

decompiled/sources/kotlin/sequences/DropTakeSequence.java

@@ -0,0 +1,6 @@
+package kotlin.sequences;
+
+/* loaded from: classes5.dex */
+public interface DropTakeSequence extends Sequence {
+    Sequence take(int i);
+}

decompiled/sources/kotlin/sequences/EmptySequence.java

@@ -0,0 +1,19 @@
+package kotlin.sequences;
+
+import java.util.Iterator;
+import kotlin.collections.EmptyIterator;
+
+/* loaded from: classes5.dex */
+public final class EmptySequence implements Sequence, DropTakeSequence {
+    public static final EmptySequence INSTANCE = new EmptySequence();
+
+    @Override // kotlin.sequences.DropTakeSequence
+    public EmptySequence take(int i) {
+        return INSTANCE;
+    }
+
+    @Override // kotlin.sequences.Sequence
+    public Iterator iterator() {
+        return EmptyIterator.INSTANCE;
+    }
+}

decompiled/sources/kotlin/sequences/FilteringSequence$iterator$1.java

@@ -0,0 +1,66 @@
+package kotlin.sequences;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public final class FilteringSequence$iterator$1 implements Iterator, KMappedMarker {
+    public final Iterator iterator;
+    public Object nextItem;
+    public int nextState;
+    public final /* synthetic */ FilteringSequence this$0;
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    public FilteringSequence$iterator$1(FilteringSequence filteringSequence) {
+        Sequence sequence;
+        this.this$0 = filteringSequence;
+        sequence = filteringSequence.sequence;
+        this.iterator = sequence.iterator();
+        this.nextState = -1;
+    }
+
+    public final void calcNext() {
+        Function1 function1;
+        boolean z;
+        while (this.iterator.hasNext()) {
+            Object next = this.iterator.next();
+            function1 = this.this$0.predicate;
+            boolean booleanValue = ((Boolean) function1.invoke(next)).booleanValue();
+            z = this.this$0.sendWhen;
+            if (booleanValue == z) {
+                this.nextItem = next;
+                this.nextState = 1;
+                return;
+            }
+        }
+        this.nextState = 0;
+    }
+
+    @Override // java.util.Iterator
+    public Object next() {
+        if (this.nextState == -1) {
+            calcNext();
+        }
+        if (this.nextState == 0) {
+            throw new NoSuchElementException();
+        }
+        Object obj = this.nextItem;
+        this.nextItem = null;
+        this.nextState = -1;
+        return obj;
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        if (this.nextState == -1) {
+            calcNext();
+        }
+        return this.nextState == 1;
+    }
+}

decompiled/sources/kotlin/sequences/FilteringSequence.java

@@ -0,0 +1,25 @@
+package kotlin.sequences;
+
+import java.util.Iterator;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class FilteringSequence implements Sequence {
+    public final Function1 predicate;
+    public final boolean sendWhen;
+    public final Sequence sequence;
+
+    public FilteringSequence(Sequence sequence, boolean z, Function1 predicate) {
+        Intrinsics.checkNotNullParameter(sequence, "sequence");
+        Intrinsics.checkNotNullParameter(predicate, "predicate");
+        this.sequence = sequence;
+        this.sendWhen = z;
+        this.predicate = predicate;
+    }
+
+    @Override // kotlin.sequences.Sequence
+    public Iterator iterator() {
+        return new FilteringSequence$iterator$1(this);
+    }
+}

decompiled/sources/kotlin/sequences/GeneratorSequence$iterator$1.java

@@ -0,0 +1,63 @@
+package kotlin.sequences;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public final class GeneratorSequence$iterator$1 implements Iterator, KMappedMarker {
+    public Object nextItem;
+    public int nextState = -2;
+    public final /* synthetic */ GeneratorSequence this$0;
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    public GeneratorSequence$iterator$1(GeneratorSequence generatorSequence) {
+        this.this$0 = generatorSequence;
+    }
+
+    private final void calcNext() {
+        Function1 function1;
+        Object invoke;
+        Function0 function0;
+        if (this.nextState == -2) {
+            function0 = this.this$0.getInitialValue;
+            invoke = function0.invoke();
+        } else {
+            function1 = this.this$0.getNextValue;
+            Object obj = this.nextItem;
+            Intrinsics.checkNotNull(obj);
+            invoke = function1.invoke(obj);
+        }
+        this.nextItem = invoke;
+        this.nextState = invoke == null ? 0 : 1;
+    }
+
+    @Override // java.util.Iterator
+    public Object next() {
+        if (this.nextState < 0) {
+            calcNext();
+        }
+        if (this.nextState == 0) {
+            throw new NoSuchElementException();
+        }
+        Object obj = this.nextItem;
+        Intrinsics.checkNotNull(obj, "null cannot be cast to non-null type T of kotlin.sequences.GeneratorSequence");
+        this.nextState = -1;
+        return obj;
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        if (this.nextState < 0) {
+            calcNext();
+        }
+        return this.nextState == 1;
+    }
+}

decompiled/sources/kotlin/sequences/GeneratorSequence.java

@@ -0,0 +1,24 @@
+package kotlin.sequences;
+
+import java.util.Iterator;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class GeneratorSequence implements Sequence {
+    public final Function0 getInitialValue;
+    public final Function1 getNextValue;
+
+    public GeneratorSequence(Function0 getInitialValue, Function1 getNextValue) {
+        Intrinsics.checkNotNullParameter(getInitialValue, "getInitialValue");
+        Intrinsics.checkNotNullParameter(getNextValue, "getNextValue");
+        this.getInitialValue = getInitialValue;
+        this.getNextValue = getNextValue;
+    }
+
+    @Override // kotlin.sequences.Sequence
+    public Iterator iterator() {
+        return new GeneratorSequence$iterator$1(this);
+    }
+}

decompiled/sources/kotlin/sequences/Sequence.java

@@ -0,0 +1,8 @@
+package kotlin.sequences;
+
+import java.util.Iterator;
+
+/* loaded from: classes5.dex */
+public interface Sequence {
+    Iterator iterator();
+}

decompiled/sources/kotlin/sequences/SequenceBuilderIterator.java

@@ -0,0 +1,149 @@
+package kotlin.sequences;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import kotlin.Result;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.coroutines.EmptyCoroutineContext;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.DebugProbesKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public final class SequenceBuilderIterator extends SequenceScope implements Iterator, Continuation, KMappedMarker {
+    public Iterator nextIterator;
+    public Continuation nextStep;
+    public Object nextValue;
+    public int state;
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    public final void setNextStep(Continuation continuation) {
+        this.nextStep = continuation;
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        while (true) {
+            int i = this.state;
+            if (i != 0) {
+                if (i != 1) {
+                    if (i == 2 || i == 3) {
+                        return true;
+                    }
+                    if (i == 4) {
+                        return false;
+                    }
+                    throw exceptionalState();
+                }
+                Iterator it = this.nextIterator;
+                Intrinsics.checkNotNull(it);
+                if (it.hasNext()) {
+                    this.state = 2;
+                    return true;
+                }
+                this.nextIterator = null;
+            }
+            this.state = 5;
+            Continuation continuation = this.nextStep;
+            Intrinsics.checkNotNull(continuation);
+            this.nextStep = null;
+            Result.Companion companion = Result.Companion;
+            continuation.resumeWith(Result.m4060constructorimpl(Unit.INSTANCE));
+        }
+    }
+
+    @Override // java.util.Iterator
+    public Object next() {
+        int i = this.state;
+        if (i == 0 || i == 1) {
+            return nextNotReady();
+        }
+        if (i == 2) {
+            this.state = 1;
+            Iterator it = this.nextIterator;
+            Intrinsics.checkNotNull(it);
+            return it.next();
+        }
+        if (i != 3) {
+            throw exceptionalState();
+        }
+        this.state = 0;
+        Object obj = this.nextValue;
+        this.nextValue = null;
+        return obj;
+    }
+
+    public final Object nextNotReady() {
+        if (hasNext()) {
+            return next();
+        }
+        throw new NoSuchElementException();
+    }
+
+    public final Throwable exceptionalState() {
+        int i = this.state;
+        if (i == 4) {
+            return new NoSuchElementException();
+        }
+        if (i == 5) {
+            return new IllegalStateException("Iterator has failed.");
+        }
+        return new IllegalStateException("Unexpected state of the iterator: " + this.state);
+    }
+
+    @Override // kotlin.sequences.SequenceScope
+    public Object yield(Object obj, Continuation continuation) {
+        Object coroutine_suspended;
+        Object coroutine_suspended2;
+        Object coroutine_suspended3;
+        this.nextValue = obj;
+        this.state = 3;
+        this.nextStep = continuation;
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        coroutine_suspended2 = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        if (coroutine_suspended == coroutine_suspended2) {
+            DebugProbesKt.probeCoroutineSuspended(continuation);
+        }
+        coroutine_suspended3 = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return coroutine_suspended == coroutine_suspended3 ? coroutine_suspended : Unit.INSTANCE;
+    }
+
+    @Override // kotlin.sequences.SequenceScope
+    public Object yieldAll(Iterator it, Continuation continuation) {
+        Object coroutine_suspended;
+        Object coroutine_suspended2;
+        Object coroutine_suspended3;
+        if (!it.hasNext()) {
+            return Unit.INSTANCE;
+        }
+        this.nextIterator = it;
+        this.state = 2;
+        this.nextStep = continuation;
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        coroutine_suspended2 = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        if (coroutine_suspended == coroutine_suspended2) {
+            DebugProbesKt.probeCoroutineSuspended(continuation);
+        }
+        coroutine_suspended3 = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return coroutine_suspended == coroutine_suspended3 ? coroutine_suspended : Unit.INSTANCE;
+    }
+
+    @Override // kotlin.coroutines.Continuation
+    public void resumeWith(Object obj) {
+        ResultKt.throwOnFailure(obj);
+        this.state = 4;
+    }
+
+    @Override // kotlin.coroutines.Continuation
+    public CoroutineContext getContext() {
+        return EmptyCoroutineContext.INSTANCE;
+    }
+}

decompiled/sources/kotlin/sequences/SequenceScope.java

@@ -0,0 +1,20 @@
+package kotlin.sequences;
+
+import java.util.Iterator;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+
+/* loaded from: classes5.dex */
+public abstract class SequenceScope {
+    public abstract Object yield(Object obj, Continuation continuation);
+
+    public abstract Object yieldAll(Iterator it, Continuation continuation);
+
+    public final Object yieldAll(Sequence sequence, Continuation continuation) {
+        Object coroutine_suspended;
+        Object yieldAll = yieldAll(sequence.iterator(), continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return yieldAll == coroutine_suspended ? yieldAll : Unit.INSTANCE;
+    }
+}

decompiled/sources/kotlin/sequences/SequencesKt.java

@@ -0,0 +1,5 @@
+package kotlin.sequences;
+
+/* loaded from: classes5.dex */
+public abstract class SequencesKt extends SequencesKt___SequencesKt {
+}

decompiled/sources/kotlin/sequences/SequencesKt__SequenceBuilderKt.java

@@ -0,0 +1,31 @@
+package kotlin.sequences;
+
+import java.util.Iterator;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class SequencesKt__SequenceBuilderKt {
+    public static Sequence sequence(final Function2 block) {
+        Intrinsics.checkNotNullParameter(block, "block");
+        return new Sequence() { // from class: kotlin.sequences.SequencesKt__SequenceBuilderKt$sequence$$inlined$Sequence$1
+            @Override // kotlin.sequences.Sequence
+            public Iterator iterator() {
+                Iterator it;
+                it = SequencesKt__SequenceBuilderKt.iterator(Function2.this);
+                return it;
+            }
+        };
+    }
+
+    public static Iterator iterator(Function2 block) {
+        Continuation createCoroutineUnintercepted;
+        Intrinsics.checkNotNullParameter(block, "block");
+        SequenceBuilderIterator sequenceBuilderIterator = new SequenceBuilderIterator();
+        createCoroutineUnintercepted = IntrinsicsKt__IntrinsicsJvmKt.createCoroutineUnintercepted(block, sequenceBuilderIterator, sequenceBuilderIterator);
+        sequenceBuilderIterator.setNextStep(createCoroutineUnintercepted);
+        return sequenceBuilderIterator;
+    }
+}

decompiled/sources/kotlin/sequences/SequencesKt__SequencesJVMKt.java

@@ -0,0 +1,5 @@
+package kotlin.sequences;
+
+/* loaded from: classes5.dex */
+public abstract class SequencesKt__SequencesJVMKt extends SequencesKt__SequenceBuilderKt {
+}

decompiled/sources/kotlin/sequences/SequencesKt__SequencesKt.java

@@ -0,0 +1,48 @@
+package kotlin.sequences;
+
+import java.util.Iterator;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class SequencesKt__SequencesKt extends SequencesKt__SequencesJVMKt {
+    public static Sequence asSequence(final Iterator it) {
+        Sequence constrainOnce;
+        Intrinsics.checkNotNullParameter(it, "<this>");
+        constrainOnce = constrainOnce(new Sequence() { // from class: kotlin.sequences.SequencesKt__SequencesKt$asSequence$$inlined$Sequence$1
+            @Override // kotlin.sequences.Sequence
+            public Iterator iterator() {
+                return it;
+            }
+        });
+        return constrainOnce;
+    }
+
+    public static final Sequence emptySequence() {
+        return EmptySequence.INSTANCE;
+    }
+
+    public static Sequence constrainOnce(Sequence sequence) {
+        Intrinsics.checkNotNullParameter(sequence, "<this>");
+        return sequence instanceof ConstrainedOnceSequence ? sequence : new ConstrainedOnceSequence(sequence);
+    }
+
+    public static Sequence generateSequence(final Object obj, Function1 nextFunction) {
+        Intrinsics.checkNotNullParameter(nextFunction, "nextFunction");
+        if (obj == null) {
+            return EmptySequence.INSTANCE;
+        }
+        return new GeneratorSequence(new Function0() { // from class: kotlin.sequences.SequencesKt__SequencesKt$generateSequence$2
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(0);
+            }
+
+            @Override // kotlin.jvm.functions.Function0
+            public final Object invoke() {
+                return obj;
+            }
+        }, nextFunction);
+    }
+}

decompiled/sources/kotlin/sequences/SequencesKt___SequencesJvmKt.java

@@ -0,0 +1,5 @@
+package kotlin.sequences;
+
+/* loaded from: classes5.dex */
+public abstract class SequencesKt___SequencesJvmKt extends SequencesKt__SequencesKt {
+}

decompiled/sources/kotlin/sequences/SequencesKt___SequencesKt$asIterable$$inlined$Iterable$1.java

@@ -0,0 +1,18 @@
+package kotlin.sequences;
+
+import java.util.Iterator;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public final class SequencesKt___SequencesKt$asIterable$$inlined$Iterable$1 implements Iterable, KMappedMarker {
+    public final /* synthetic */ Sequence $this_asIterable$inlined;
+
+    public SequencesKt___SequencesKt$asIterable$$inlined$Iterable$1(Sequence sequence) {
+        this.$this_asIterable$inlined = sequence;
+    }
+
+    @Override // java.lang.Iterable
+    public Iterator iterator() {
+        return this.$this_asIterable$inlined.iterator();
+    }
+}

decompiled/sources/kotlin/sequences/SequencesKt___SequencesKt.java

@@ -0,0 +1,169 @@
+package kotlin.sequences;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import kotlin.collections.CollectionsKt__CollectionsJVMKt;
+import kotlin.collections.CollectionsKt__CollectionsKt;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.StringsKt__AppendableKt;
+
+/* loaded from: classes5.dex */
+public abstract class SequencesKt___SequencesKt extends SequencesKt___SequencesJvmKt {
+    public static boolean contains(Sequence sequence, Object obj) {
+        Intrinsics.checkNotNullParameter(sequence, "<this>");
+        return indexOf(sequence, obj) >= 0;
+    }
+
+    public static Object firstOrNull(Sequence sequence) {
+        Intrinsics.checkNotNullParameter(sequence, "<this>");
+        Iterator it = sequence.iterator();
+        if (it.hasNext()) {
+            return it.next();
+        }
+        return null;
+    }
+
+    public static final int indexOf(Sequence sequence, Object obj) {
+        Intrinsics.checkNotNullParameter(sequence, "<this>");
+        int i = 0;
+        for (Object obj2 : sequence) {
+            if (i < 0) {
+                CollectionsKt__CollectionsKt.throwIndexOverflow();
+            }
+            if (Intrinsics.areEqual(obj, obj2)) {
+                return i;
+            }
+            i++;
+        }
+        return -1;
+    }
+
+    public static Sequence filter(Sequence sequence, Function1 predicate) {
+        Intrinsics.checkNotNullParameter(sequence, "<this>");
+        Intrinsics.checkNotNullParameter(predicate, "predicate");
+        return new FilteringSequence(sequence, true, predicate);
+    }
+
+    public static final Sequence filterNot(Sequence sequence, Function1 predicate) {
+        Intrinsics.checkNotNullParameter(sequence, "<this>");
+        Intrinsics.checkNotNullParameter(predicate, "predicate");
+        return new FilteringSequence(sequence, false, predicate);
+    }
+
+    public static final Sequence filterNotNull(Sequence sequence) {
+        Intrinsics.checkNotNullParameter(sequence, "<this>");
+        Sequence filterNot = filterNot(sequence, new Function1() { // from class: kotlin.sequences.SequencesKt___SequencesKt$filterNotNull$1
+            @Override // kotlin.jvm.functions.Function1
+            public final Boolean invoke(Object obj) {
+                return Boolean.valueOf(obj == null);
+            }
+        });
+        Intrinsics.checkNotNull(filterNot, "null cannot be cast to non-null type kotlin.sequences.Sequence<T of kotlin.sequences.SequencesKt___SequencesKt.filterNotNull>");
+        return filterNot;
+    }
+
+    public static Sequence take(Sequence sequence, int i) {
+        Intrinsics.checkNotNullParameter(sequence, "<this>");
+        if (i >= 0) {
+            if (i == 0) {
+                return SequencesKt__SequencesKt.emptySequence();
+            }
+            return sequence instanceof DropTakeSequence ? ((DropTakeSequence) sequence).take(i) : new TakeSequence(sequence, i);
+        }
+        throw new IllegalArgumentException(("Requested element count " + i + " is less than zero.").toString());
+    }
+
+    public static List toList(Sequence sequence) {
+        Intrinsics.checkNotNullParameter(sequence, "<this>");
+        Iterator it = sequence.iterator();
+        if (!it.hasNext()) {
+            return CollectionsKt__CollectionsKt.emptyList();
+        }
+        Object next = it.next();
+        if (!it.hasNext()) {
+            return CollectionsKt__CollectionsJVMKt.listOf(next);
+        }
+        ArrayList arrayList = new ArrayList();
+        arrayList.add(next);
+        while (it.hasNext()) {
+            arrayList.add(it.next());
+        }
+        return arrayList;
+    }
+
+    public static Sequence map(Sequence sequence, Function1 transform) {
+        Intrinsics.checkNotNullParameter(sequence, "<this>");
+        Intrinsics.checkNotNullParameter(transform, "transform");
+        return new TransformingSequence(sequence, transform);
+    }
+
+    public static Sequence mapNotNull(Sequence sequence, Function1 transform) {
+        Intrinsics.checkNotNullParameter(sequence, "<this>");
+        Intrinsics.checkNotNullParameter(transform, "transform");
+        return filterNotNull(new TransformingSequence(sequence, transform));
+    }
+
+    public static final Appendable joinTo(Sequence sequence, Appendable buffer, CharSequence separator, CharSequence prefix, CharSequence postfix, int i, CharSequence truncated, Function1 function1) {
+        Intrinsics.checkNotNullParameter(sequence, "<this>");
+        Intrinsics.checkNotNullParameter(buffer, "buffer");
+        Intrinsics.checkNotNullParameter(separator, "separator");
+        Intrinsics.checkNotNullParameter(prefix, "prefix");
+        Intrinsics.checkNotNullParameter(postfix, "postfix");
+        Intrinsics.checkNotNullParameter(truncated, "truncated");
+        buffer.append(prefix);
+        int i2 = 0;
+        for (Object obj : sequence) {
+            i2++;
+            if (i2 > 1) {
+                buffer.append(separator);
+            }
+            if (i >= 0 && i2 > i) {
+                break;
+            }
+            StringsKt__AppendableKt.appendElement(buffer, obj, function1);
+        }
+        if (i >= 0 && i2 > i) {
+            buffer.append(truncated);
+        }
+        buffer.append(postfix);
+        return buffer;
+    }
+
+    public static /* synthetic */ String joinToString$default(Sequence sequence, CharSequence charSequence, CharSequence charSequence2, CharSequence charSequence3, int i, CharSequence charSequence4, Function1 function1, int i2, Object obj) {
+        if ((i2 & 1) != 0) {
+            charSequence = ", ";
+        }
+        CharSequence charSequence5 = (i2 & 2) != 0 ? "" : charSequence2;
+        CharSequence charSequence6 = (i2 & 4) == 0 ? charSequence3 : "";
+        if ((i2 & 8) != 0) {
+            i = -1;
+        }
+        int i3 = i;
+        if ((i2 & 16) != 0) {
+            charSequence4 = "...";
+        }
+        CharSequence charSequence7 = charSequence4;
+        if ((i2 & 32) != 0) {
+            function1 = null;
+        }
+        return joinToString(sequence, charSequence, charSequence5, charSequence6, i3, charSequence7, function1);
+    }
+
+    public static final String joinToString(Sequence sequence, CharSequence separator, CharSequence prefix, CharSequence postfix, int i, CharSequence truncated, Function1 function1) {
+        Intrinsics.checkNotNullParameter(sequence, "<this>");
+        Intrinsics.checkNotNullParameter(separator, "separator");
+        Intrinsics.checkNotNullParameter(prefix, "prefix");
+        Intrinsics.checkNotNullParameter(postfix, "postfix");
+        Intrinsics.checkNotNullParameter(truncated, "truncated");
+        String sb = ((StringBuilder) joinTo(sequence, new StringBuilder(), separator, prefix, postfix, i, truncated, function1)).toString();
+        Intrinsics.checkNotNullExpressionValue(sb, "toString(...)");
+        return sb;
+    }
+
+    public static Iterable asIterable(Sequence sequence) {
+        Intrinsics.checkNotNullParameter(sequence, "<this>");
+        return new SequencesKt___SequencesKt$asIterable$$inlined$Iterable$1(sequence);
+    }
+}

decompiled/sources/kotlin/sequences/TakeSequence$iterator$1.java

@@ -0,0 +1,40 @@
+package kotlin.sequences;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public final class TakeSequence$iterator$1 implements Iterator, KMappedMarker {
+    public final Iterator iterator;
+    public int left;
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    public TakeSequence$iterator$1(TakeSequence takeSequence) {
+        int i;
+        Sequence sequence;
+        i = takeSequence.count;
+        this.left = i;
+        sequence = takeSequence.sequence;
+        this.iterator = sequence.iterator();
+    }
+
+    @Override // java.util.Iterator
+    public Object next() {
+        int i = this.left;
+        if (i == 0) {
+            throw new NoSuchElementException();
+        }
+        this.left = i - 1;
+        return this.iterator.next();
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.left > 0 && this.iterator.hasNext();
+    }
+}

decompiled/sources/kotlin/sequences/TakeSequence.java

@@ -0,0 +1,30 @@
+package kotlin.sequences;
+
+import java.util.Iterator;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class TakeSequence implements Sequence, DropTakeSequence {
+    public final int count;
+    public final Sequence sequence;
+
+    public TakeSequence(Sequence sequence, int i) {
+        Intrinsics.checkNotNullParameter(sequence, "sequence");
+        this.sequence = sequence;
+        this.count = i;
+        if (i >= 0) {
+            return;
+        }
+        throw new IllegalArgumentException(("count must be non-negative, but was " + i + '.').toString());
+    }
+
+    @Override // kotlin.sequences.DropTakeSequence
+    public Sequence take(int i) {
+        return i >= this.count ? this : new TakeSequence(this.sequence, i);
+    }
+
+    @Override // kotlin.sequences.Sequence
+    public Iterator iterator() {
+        return new TakeSequence$iterator$1(this);
+    }
+}

decompiled/sources/kotlin/sequences/TransformingSequence$iterator$1.java

@@ -0,0 +1,35 @@
+package kotlin.sequences;
+
+import java.util.Iterator;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public final class TransformingSequence$iterator$1 implements Iterator, KMappedMarker {
+    public final Iterator iterator;
+    public final /* synthetic */ TransformingSequence this$0;
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    public TransformingSequence$iterator$1(TransformingSequence transformingSequence) {
+        Sequence sequence;
+        this.this$0 = transformingSequence;
+        sequence = transformingSequence.sequence;
+        this.iterator = sequence.iterator();
+    }
+
+    @Override // java.util.Iterator
+    public Object next() {
+        Function1 function1;
+        function1 = this.this$0.transformer;
+        return function1.invoke(this.iterator.next());
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.iterator.hasNext();
+    }
+}

decompiled/sources/kotlin/sequences/TransformingSequence.java

@@ -0,0 +1,23 @@
+package kotlin.sequences;
+
+import java.util.Iterator;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class TransformingSequence implements Sequence {
+    public final Sequence sequence;
+    public final Function1 transformer;
+
+    public TransformingSequence(Sequence sequence, Function1 transformer) {
+        Intrinsics.checkNotNullParameter(sequence, "sequence");
+        Intrinsics.checkNotNullParameter(transformer, "transformer");
+        this.sequence = sequence;
+        this.transformer = transformer;
+    }
+
+    @Override // kotlin.sequences.Sequence
+    public Iterator iterator() {
+        return new TransformingSequence$iterator$1(this);
+    }
+}