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/Deprecated.java

@@ -0,0 +1,23 @@
+package kotlin;
+
+import com.applovin.sdk.AppLovinEventTypes;
+import com.facebook.ads.redexgen.core.EnumC1344dI;
+import com.fyber.inneractive.sdk.bidder.TokenParametersOuterClass$TokenParameters;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import kotlin.annotation.MustBeDocumented;
+
+/* JADX WARN: Method from annotation default annotation not found: level */
+/* JADX WARN: Method from annotation default annotation not found: replaceWith */
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.ANNOTATION_TYPE})
+@MustBeDocumented
+@Metadata(d1 = {"\u0000\u001e\n\u0002\u0018\u0002\n\u0002\u0010\u001b\n\u0000\n\u0002\u0010\u000e\n\u0000\n\u0002\u0018\u0002\n\u0000\n\u0002\u0018\u0002\n\u0002\b\u0004\b\u0087\u0002\u0018\u00002\u00020\u0001B\u001c\u0012\u0006\u0010\u0002\u001a\u00020\u0003\u0012\b\b\u0002\u0010\u0004\u001a\u00020\u0005\u0012\b\b\u0002\u0010\u0006\u001a\u00020\u0007R\u000f\u0010\u0006\u001a\u00020\u0007¢\u0006\u0006\u001a\u0004\b\u0006\u0010\bR\u000f\u0010\u0002\u001a\u00020\u0003¢\u0006\u0006\u001a\u0004\b\u0002\u0010\tR\u000f\u0010\u0004\u001a\u00020\u0005¢\u0006\u0006\u001a\u0004\b\u0004\u0010\n¨\u0006\u000b"}, d2 = {"Lkotlin/Deprecated;", "", "message", "", "replaceWith", "Lkotlin/ReplaceWith;", AppLovinEventTypes.USER_COMPLETED_LEVEL, "Lkotlin/DeprecationLevel;", "()Lkotlin/DeprecationLevel;", "()Ljava/lang/String;", "()Lkotlin/ReplaceWith;", "kotlin-stdlib"}, k = 1, mv = {1, 9, 0}, xi = TokenParametersOuterClass$TokenParameters.LOWPOWERMODE_FIELD_NUMBER)
+@kotlin.annotation.Target(allowedTargets = {EnumC1344dI.A05, EnumC1344dI.A0A, EnumC1344dI.A0C, EnumC1344dI.A04, EnumC1344dI.A06, EnumC1344dI.A0E, EnumC1344dI.A0D, EnumC1344dI.A0G})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: assets/audience_network.dex */
+public @interface Deprecated {
+}

decompiled/sources/kotlin/DeprecatedSinceKotlin.java

@@ -0,0 +1,23 @@
+package kotlin;
+
+import com.facebook.ads.redexgen.core.EnumC1344dI;
+import com.fyber.inneractive.sdk.bidder.TokenParametersOuterClass$TokenParameters;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import kotlin.annotation.MustBeDocumented;
+
+/* JADX WARN: Method from annotation default annotation not found: errorSince */
+/* JADX WARN: Method from annotation default annotation not found: hiddenSince */
+/* JADX WARN: Method from annotation default annotation not found: warningSince */
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.ANNOTATION_TYPE})
+@MustBeDocumented
+@Metadata(d1 = {"\u0000\u0012\n\u0002\u0018\u0002\n\u0002\u0010\u001b\n\u0000\n\u0002\u0010\u000e\n\u0002\b\u0004\b\u0087\u0002\u0018\u00002\u00020\u0001B\u001e\u0012\b\b\u0002\u0010\u0002\u001a\u00020\u0003\u0012\b\b\u0002\u0010\u0004\u001a\u00020\u0003\u0012\b\b\u0002\u0010\u0005\u001a\u00020\u0003R\u000f\u0010\u0004\u001a\u00020\u0003¢\u0006\u0006\u001a\u0004\b\u0004\u0010\u0006R\u000f\u0010\u0005\u001a\u00020\u0003¢\u0006\u0006\u001a\u0004\b\u0005\u0010\u0006R\u000f\u0010\u0002\u001a\u00020\u0003¢\u0006\u0006\u001a\u0004\b\u0002\u0010\u0006¨\u0006\u0007"}, d2 = {"Lkotlin/DeprecatedSinceKotlin;", "", "warningSince", "", "errorSince", "hiddenSince", "()Ljava/lang/String;", "kotlin-stdlib"}, k = 1, mv = {1, 9, 0}, xi = TokenParametersOuterClass$TokenParameters.LOWPOWERMODE_FIELD_NUMBER)
+@kotlin.annotation.Target(allowedTargets = {EnumC1344dI.A05, EnumC1344dI.A0A, EnumC1344dI.A0C, EnumC1344dI.A04, EnumC1344dI.A06, EnumC1344dI.A0E, EnumC1344dI.A0D, EnumC1344dI.A0G})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: assets/audience_network.dex */
+public @interface DeprecatedSinceKotlin {
+}

decompiled/sources/kotlin/ExceptionsKt.java

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

decompiled/sources/kotlin/ExceptionsKt__ExceptionsKt.java

@@ -0,0 +1,28 @@
+package kotlin;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import kotlin.internal.PlatformImplementationsKt;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class ExceptionsKt__ExceptionsKt {
+    public static String stackTraceToString(Throwable th) {
+        Intrinsics.checkNotNullParameter(th, "<this>");
+        StringWriter stringWriter = new StringWriter();
+        PrintWriter printWriter = new PrintWriter(stringWriter);
+        th.printStackTrace(printWriter);
+        printWriter.flush();
+        String stringWriter2 = stringWriter.toString();
+        Intrinsics.checkNotNullExpressionValue(stringWriter2, "toString(...)");
+        return stringWriter2;
+    }
+
+    public static void addSuppressed(Throwable th, Throwable exception) {
+        Intrinsics.checkNotNullParameter(th, "<this>");
+        Intrinsics.checkNotNullParameter(exception, "exception");
+        if (th != exception) {
+            PlatformImplementationsKt.IMPLEMENTATIONS.addSuppressed(th, exception);
+        }
+    }
+}

decompiled/sources/kotlin/Function.java

@@ -0,0 +1,5 @@
+package kotlin;
+
+/* loaded from: classes5.dex */
+public interface Function {
+}

decompiled/sources/kotlin/InitializedLazyImpl.java

@@ -0,0 +1,26 @@
+package kotlin;
+
+import java.io.Serializable;
+
+/* loaded from: classes5.dex */
+public final class InitializedLazyImpl implements Lazy, Serializable {
+    public final Object value;
+
+    @Override // kotlin.Lazy
+    public Object getValue() {
+        return this.value;
+    }
+
+    @Override // kotlin.Lazy
+    public boolean isInitialized() {
+        return true;
+    }
+
+    public InitializedLazyImpl(Object obj) {
+        this.value = obj;
+    }
+
+    public String toString() {
+        return String.valueOf(getValue());
+    }
+}

decompiled/sources/kotlin/KotlinNothingValueException.java

@@ -0,0 +1,5 @@
+package kotlin;
+
+/* loaded from: classes5.dex */
+public final class KotlinNothingValueException extends RuntimeException {
+}

decompiled/sources/kotlin/KotlinNullPointerException.java

@@ -0,0 +1,11 @@
+package kotlin;
+
+/* loaded from: classes5.dex */
+public class KotlinNullPointerException extends NullPointerException {
+    public KotlinNullPointerException() {
+    }
+
+    public KotlinNullPointerException(String str) {
+        super(str);
+    }
+}

decompiled/sources/kotlin/KotlinVersion.java

@@ -0,0 +1,66 @@
+package kotlin;
+
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.ranges.IntRange;
+
+/* loaded from: classes5.dex */
+public final class KotlinVersion implements Comparable {
+    public final int major;
+    public final int minor;
+    public final int patch;
+    public final int version;
+    public static final Companion Companion = new Companion(null);
+    public static final KotlinVersion CURRENT = KotlinVersionCurrentValue.get();
+
+    public int hashCode() {
+        return this.version;
+    }
+
+    public KotlinVersion(int i, int i2, int i3) {
+        this.major = i;
+        this.minor = i2;
+        this.patch = i3;
+        this.version = versionOf(i, i2, i3);
+    }
+
+    public final int versionOf(int i, int i2, int i3) {
+        if (new IntRange(0, 255).contains(i) && new IntRange(0, 255).contains(i2) && new IntRange(0, 255).contains(i3)) {
+            return (i << 16) + (i2 << 8) + i3;
+        }
+        throw new IllegalArgumentException(("Version components are out of range: " + i + '.' + i2 + '.' + i3).toString());
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(this.major);
+        sb.append('.');
+        sb.append(this.minor);
+        sb.append('.');
+        sb.append(this.patch);
+        return sb.toString();
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        KotlinVersion kotlinVersion = obj instanceof KotlinVersion ? (KotlinVersion) obj : null;
+        return kotlinVersion != null && this.version == kotlinVersion.version;
+    }
+
+    @Override // java.lang.Comparable
+    public int compareTo(KotlinVersion other) {
+        Intrinsics.checkNotNullParameter(other, "other");
+        return this.version - other.version;
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+}

decompiled/sources/kotlin/KotlinVersionCurrentValue.java

@@ -0,0 +1,10 @@
+package kotlin;
+
+/* loaded from: classes5.dex */
+public final class KotlinVersionCurrentValue {
+    public static final KotlinVersionCurrentValue INSTANCE = new KotlinVersionCurrentValue();
+
+    public static final KotlinVersion get() {
+        return new KotlinVersion(1, 9, 24);
+    }
+}

decompiled/sources/kotlin/Lazy.java

@@ -0,0 +1,8 @@
+package kotlin;
+
+/* loaded from: classes5.dex */
+public interface Lazy {
+    Object getValue();
+
+    boolean isInitialized();
+}

decompiled/sources/kotlin/LazyKt.java

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

decompiled/sources/kotlin/LazyKt__LazyJVMKt.java

@@ -0,0 +1,50 @@
+package kotlin;
+
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class LazyKt__LazyJVMKt {
+
+    public /* synthetic */ class WhenMappings {
+        public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+        static {
+            int[] iArr = new int[LazyThreadSafetyMode.values().length];
+            try {
+                iArr[LazyThreadSafetyMode.SYNCHRONIZED.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                iArr[LazyThreadSafetyMode.PUBLICATION.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                iArr[LazyThreadSafetyMode.NONE.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            $EnumSwitchMapping$0 = iArr;
+        }
+    }
+
+    public static Lazy lazy(Function0 initializer) {
+        Intrinsics.checkNotNullParameter(initializer, "initializer");
+        return new SynchronizedLazyImpl(initializer, null, 2, null);
+    }
+
+    public static Lazy lazy(LazyThreadSafetyMode mode, Function0 initializer) {
+        Intrinsics.checkNotNullParameter(mode, "mode");
+        Intrinsics.checkNotNullParameter(initializer, "initializer");
+        int i = WhenMappings.$EnumSwitchMapping$0[mode.ordinal()];
+        if (i == 1) {
+            return new SynchronizedLazyImpl(initializer, null, 2, null);
+        }
+        if (i == 2) {
+            return new SafePublicationLazyImpl(initializer);
+        }
+        if (i == 3) {
+            return new UnsafeLazyImpl(initializer);
+        }
+        throw new NoWhenBranchMatchedException();
+    }
+}

decompiled/sources/kotlin/LazyKt__LazyKt.java

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

decompiled/sources/kotlin/LazyThreadSafetyMode.java

@@ -0,0 +1,40 @@
+package kotlin;
+
+import kotlin.enums.EnumEntries;
+import kotlin.enums.EnumEntriesKt;
+
+/* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
+/* JADX WARN: Unknown enum class pattern. Please report as an issue! */
+/* loaded from: classes5.dex */
+public final class LazyThreadSafetyMode {
+    private static final /* synthetic */ EnumEntries $ENTRIES;
+    private static final /* synthetic */ LazyThreadSafetyMode[] $VALUES;
+    public static final LazyThreadSafetyMode SYNCHRONIZED = new LazyThreadSafetyMode("SYNCHRONIZED", 0);
+    public static final LazyThreadSafetyMode PUBLICATION = new LazyThreadSafetyMode("PUBLICATION", 1);
+    public static final LazyThreadSafetyMode NONE = new LazyThreadSafetyMode("NONE", 2);
+
+    private static final /* synthetic */ LazyThreadSafetyMode[] $values() {
+        return new LazyThreadSafetyMode[]{SYNCHRONIZED, PUBLICATION, NONE};
+    }
+
+    public static EnumEntries getEntries() {
+        return $ENTRIES;
+    }
+
+    public static LazyThreadSafetyMode valueOf(String str) {
+        return (LazyThreadSafetyMode) Enum.valueOf(LazyThreadSafetyMode.class, str);
+    }
+
+    public static LazyThreadSafetyMode[] values() {
+        return (LazyThreadSafetyMode[]) $VALUES.clone();
+    }
+
+    private LazyThreadSafetyMode(String str, int i) {
+    }
+
+    static {
+        LazyThreadSafetyMode[] $values = $values();
+        $VALUES = $values;
+        $ENTRIES = EnumEntriesKt.enumEntries($values);
+    }
+}

decompiled/sources/kotlin/Metadata.java

@@ -0,0 +1,28 @@
+package kotlin;
+
+import com.facebook.ads.redexgen.core.EnumC1344dI;
+import com.facebook.ads.redexgen.core.EnumC1345dJ;
+import com.fyber.inneractive.sdk.bidder.TokenParametersOuterClass$TokenParameters;
+import com.mbridge.msdk.foundation.entity.CampaignEx;
+import com.unity3d.ads.core.domain.HandleInvocationsFromAdViewer;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/* JADX WARN: Method from annotation default annotation not found: bv */
+/* JADX WARN: Method from annotation default annotation not found: d1 */
+/* JADX WARN: Method from annotation default annotation not found: d2 */
+/* JADX WARN: Method from annotation default annotation not found: k */
+/* JADX WARN: Method from annotation default annotation not found: mv */
+/* JADX WARN: Method from annotation default annotation not found: pn */
+/* JADX WARN: Method from annotation default annotation not found: xi */
+/* JADX WARN: Method from annotation default annotation not found: xs */
+@Target({ElementType.TYPE})
+@Metadata(d1 = {"\u0000$\n\u0002\u0018\u0002\n\u0002\u0010\u001b\n\u0000\n\u0002\u0010\b\n\u0000\n\u0002\u0010\u0015\n\u0002\b\u0002\n\u0002\u0010\u0011\n\u0002\u0010\u000e\n\u0002\b\u0015\b\u0087\u0002\u0018\u00002\u00020\u0001B\\\u0012\b\b\u0002\u0010\u0002\u001a\u00020\u0003\u0012\b\b\u0002\u0010\u0004\u001a\u00020\u0005\u0012\b\b\u0002\u0010\u0006\u001a\u00020\u0005\u0012\u000e\b\u0002\u0010\u0007\u001a\b\u0012\u0004\u0012\u00020\t0\b\u0012\u000e\b\u0002\u0010\n\u001a\b\u0012\u0004\u0012\u00020\t0\b\u0012\b\b\u0002\u0010\u000b\u001a\u00020\t\u0012\b\b\u0002\u0010\f\u001a\u00020\t\u0012\b\b\u0002\u0010\r\u001a\u00020\u0003R\u0018\u0010\u0006\u001a\u00020\u0005X\u0087\u0004¢\u0006\f\u0012\u0004\b\u000e\u0010\u000f\u001a\u0004\b\u0010\u0010\u0011R\u0017\u0010\u0007\u001a\b\u0012\u0004\u0012\u00020\t0\b8\u0007¢\u0006\u0006\u001a\u0004\b\u0012\u0010\u0013R\u0017\u0010\n\u001a\b\u0012\u0004\u0012\u00020\t0\b8\u0007¢\u0006\u0006\u001a\u0004\b\u0014\u0010\u0013R\u0018\u0010\r\u001a\u00020\u0003X\u0087\u0004¢\u0006\f\u0012\u0004\b\u0015\u0010\u000f\u001a\u0004\b\u0016\u0010\u0017R\u0011\u0010\u000b\u001a\u00020\t8\u0007¢\u0006\u0006\u001a\u0004\b\u0018\u0010\u0019R\u0011\u0010\u0002\u001a\u00020\u00038\u0007¢\u0006\u0006\u001a\u0004\b\u001a\u0010\u0017R\u0011\u0010\u0004\u001a\u00020\u00058\u0007¢\u0006\u0006\u001a\u0004\b\u001b\u0010\u0011R\u0018\u0010\f\u001a\u00020\tX\u0087\u0004¢\u0006\f\u0012\u0004\b\u001c\u0010\u000f\u001a\u0004\b\u001d\u0010\u0019¨\u0006\u001e"}, d2 = {"Lkotlin/Metadata;", "", "kind", "", "metadataVersion", "", "bytecodeVersion", "data1", "", "", "data2", "extraString", HandleInvocationsFromAdViewer.KEY_PACKAGE_NAME, "extraInt", "bv$annotations", "()V", "bv", "()[I", "d1", "()[Ljava/lang/String;", "d2", "xi$annotations", "xi", "()I", "xs", "()Ljava/lang/String;", CampaignEx.JSON_KEY_AD_K, "mv", "pn$annotations", "pn", "kotlin-stdlib"}, k = 1, mv = {1, 9, 0}, xi = TokenParametersOuterClass$TokenParameters.LOWPOWERMODE_FIELD_NUMBER)
+@kotlin.annotation.Target(allowedTargets = {EnumC1344dI.A05})
+@Retention(RetentionPolicy.RUNTIME)
+@kotlin.annotation.Retention(EnumC1345dJ.A05)
+/* loaded from: assets/audience_network.dex */
+public @interface Metadata {
+}

decompiled/sources/kotlin/NoWhenBranchMatchedException.java

@@ -0,0 +1,5 @@
+package kotlin;
+
+/* loaded from: classes5.dex */
+public class NoWhenBranchMatchedException extends RuntimeException {
+}

decompiled/sources/kotlin/NotImplementedError.java

@@ -0,0 +1,17 @@
+package kotlin;
+
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class NotImplementedError extends Error {
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public NotImplementedError(String message) {
+        super(message);
+        Intrinsics.checkNotNullParameter(message, "message");
+    }
+
+    public /* synthetic */ NotImplementedError(String str, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this((i & 1) != 0 ? "An operation is not implemented." : str);
+    }
+}

decompiled/sources/kotlin/Pair.java

@@ -0,0 +1,53 @@
+package kotlin;
+
+import java.io.Serializable;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class Pair implements Serializable {
+    public final Object first;
+    public final Object second;
+
+    public final Object component1() {
+        return this.first;
+    }
+
+    public final Object component2() {
+        return this.second;
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof Pair)) {
+            return false;
+        }
+        Pair pair = (Pair) obj;
+        return Intrinsics.areEqual(this.first, pair.first) && Intrinsics.areEqual(this.second, pair.second);
+    }
+
+    public final Object getFirst() {
+        return this.first;
+    }
+
+    public final Object getSecond() {
+        return this.second;
+    }
+
+    public int hashCode() {
+        Object obj = this.first;
+        int hashCode = (obj == null ? 0 : obj.hashCode()) * 31;
+        Object obj2 = this.second;
+        return hashCode + (obj2 != null ? obj2.hashCode() : 0);
+    }
+
+    public Pair(Object obj, Object obj2) {
+        this.first = obj;
+        this.second = obj2;
+    }
+
+    public String toString() {
+        return '(' + this.first + ", " + this.second + ')';
+    }
+}

decompiled/sources/kotlin/ReplaceWith.java

@@ -0,0 +1,20 @@
+package kotlin;
+
+import com.facebook.ads.redexgen.core.EnumC1345dJ;
+import com.fyber.inneractive.sdk.bidder.TokenParametersOuterClass$TokenParameters;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import kotlin.annotation.MustBeDocumented;
+
+@Target({})
+@kotlin.annotation.Target(allowedTargets = {})
+@Retention(RetentionPolicy.CLASS)
+@kotlin.annotation.Retention(EnumC1345dJ.A04)
+@MustBeDocumented
+@Metadata(d1 = {"\u0000\u0018\n\u0002\u0018\u0002\n\u0002\u0010\u001b\n\u0000\n\u0002\u0010\u000e\n\u0000\n\u0002\u0010\u0011\n\u0002\b\u0003\b\u0087\u0002\u0018\u00002\u00020\u0001B\u001c\u0012\u0006\u0010\u0002\u001a\u00020\u0003\u0012\u0012\u0010\u0004\u001a\n\u0012\u0006\b\u0001\u0012\u00020\u00030\u0005\"\u00020\u0003R\u000f\u0010\u0002\u001a\u00020\u0003¢\u0006\u0006\u001a\u0004\b\u0002\u0010\u0006R\u0017\u0010\u0004\u001a\n\u0012\u0006\b\u0001\u0012\u00020\u00030\u0005¢\u0006\u0006\u001a\u0004\b\u0004\u0010\u0007¨\u0006\b"}, d2 = {"Lkotlin/ReplaceWith;", "", "expression", "", "imports", "", "()Ljava/lang/String;", "()[Ljava/lang/String;", "kotlin-stdlib"}, k = 1, mv = {1, 9, 0}, xi = TokenParametersOuterClass$TokenParameters.LOWPOWERMODE_FIELD_NUMBER)
+@Documented
+/* loaded from: assets/audience_network.dex */
+public @interface ReplaceWith {
+}

decompiled/sources/kotlin/Result.java

@@ -0,0 +1,111 @@
+package kotlin;
+
+import java.io.Serializable;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class Result implements Serializable {
+    public static final Companion Companion = new Companion(null);
+    public final Object value;
+
+    /* renamed from: box-impl, reason: not valid java name */
+    public static final /* synthetic */ Result m4059boximpl(Object obj) {
+        return new Result(obj);
+    }
+
+    /* renamed from: constructor-impl, reason: not valid java name */
+    public static Object m4060constructorimpl(Object obj) {
+        return obj;
+    }
+
+    /* renamed from: equals-impl, reason: not valid java name */
+    public static boolean m4061equalsimpl(Object obj, Object obj2) {
+        return (obj2 instanceof Result) && Intrinsics.areEqual(obj, ((Result) obj2).m4067unboximpl());
+    }
+
+    /* renamed from: hashCode-impl, reason: not valid java name */
+    public static int m4063hashCodeimpl(Object obj) {
+        if (obj == null) {
+            return 0;
+        }
+        return obj.hashCode();
+    }
+
+    public boolean equals(Object obj) {
+        return m4061equalsimpl(this.value, obj);
+    }
+
+    public int hashCode() {
+        return m4063hashCodeimpl(this.value);
+    }
+
+    /* renamed from: unbox-impl, reason: not valid java name */
+    public final /* synthetic */ Object m4067unboximpl() {
+        return this.value;
+    }
+
+    public /* synthetic */ Result(Object obj) {
+        this.value = obj;
+    }
+
+    /* renamed from: isSuccess-impl, reason: not valid java name */
+    public static final boolean m4065isSuccessimpl(Object obj) {
+        return !(obj instanceof Failure);
+    }
+
+    /* renamed from: isFailure-impl, reason: not valid java name */
+    public static final boolean m4064isFailureimpl(Object obj) {
+        return obj instanceof Failure;
+    }
+
+    /* renamed from: exceptionOrNull-impl, reason: not valid java name */
+    public static final Throwable m4062exceptionOrNullimpl(Object obj) {
+        if (obj instanceof Failure) {
+            return ((Failure) obj).exception;
+        }
+        return null;
+    }
+
+    public String toString() {
+        return m4066toStringimpl(this.value);
+    }
+
+    /* renamed from: toString-impl, reason: not valid java name */
+    public static String m4066toStringimpl(Object obj) {
+        if (obj instanceof Failure) {
+            return ((Failure) obj).toString();
+        }
+        return "Success(" + obj + ')';
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+
+    public static final class Failure implements Serializable {
+        public final Throwable exception;
+
+        public Failure(Throwable exception) {
+            Intrinsics.checkNotNullParameter(exception, "exception");
+            this.exception = exception;
+        }
+
+        public boolean equals(Object obj) {
+            return (obj instanceof Failure) && Intrinsics.areEqual(this.exception, ((Failure) obj).exception);
+        }
+
+        public int hashCode() {
+            return this.exception.hashCode();
+        }
+
+        public String toString() {
+            return "Failure(" + this.exception + ')';
+        }
+    }
+}

decompiled/sources/kotlin/ResultKt.java

@@ -0,0 +1,18 @@
+package kotlin;
+
+import kotlin.Result;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class ResultKt {
+    public static final Object createFailure(Throwable exception) {
+        Intrinsics.checkNotNullParameter(exception, "exception");
+        return new Result.Failure(exception);
+    }
+
+    public static final void throwOnFailure(Object obj) {
+        if (obj instanceof Result.Failure) {
+            throw ((Result.Failure) obj).exception;
+        }
+    }
+}

decompiled/sources/kotlin/SafePublicationLazyImpl.java

@@ -0,0 +1,67 @@
+package kotlin;
+
+import androidx.concurrent.futures.AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0;
+import java.io.Serializable;
+import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class SafePublicationLazyImpl implements Lazy, Serializable {
+    public static final Companion Companion = new Companion(null);
+    public static final AtomicReferenceFieldUpdater valueUpdater = AtomicReferenceFieldUpdater.newUpdater(SafePublicationLazyImpl.class, Object.class, "_value");
+    public volatile Object _value;
+
+    /* renamed from: final, reason: not valid java name */
+    public final Object f3083final;
+    public volatile Function0 initializer;
+
+    public SafePublicationLazyImpl(Function0 initializer) {
+        Intrinsics.checkNotNullParameter(initializer, "initializer");
+        this.initializer = initializer;
+        UNINITIALIZED_VALUE uninitialized_value = UNINITIALIZED_VALUE.INSTANCE;
+        this._value = uninitialized_value;
+        this.f3083final = uninitialized_value;
+    }
+
+    @Override // kotlin.Lazy
+    public Object getValue() {
+        Object obj = this._value;
+        UNINITIALIZED_VALUE uninitialized_value = UNINITIALIZED_VALUE.INSTANCE;
+        if (obj != uninitialized_value) {
+            return obj;
+        }
+        Function0 function0 = this.initializer;
+        if (function0 != null) {
+            Object invoke = function0.invoke();
+            if (AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0.m(valueUpdater, this, uninitialized_value, invoke)) {
+                this.initializer = null;
+                return invoke;
+            }
+        }
+        return this._value;
+    }
+
+    @Override // kotlin.Lazy
+    public boolean isInitialized() {
+        return this._value != UNINITIALIZED_VALUE.INSTANCE;
+    }
+
+    public String toString() {
+        return isInitialized() ? String.valueOf(getValue()) : "Lazy value not initialized yet.";
+    }
+
+    private final Object writeReplace() {
+        return new InitializedLazyImpl(getValue());
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+}

decompiled/sources/kotlin/SynchronizedLazyImpl.java

@@ -0,0 +1,58 @@
+package kotlin;
+
+import java.io.Serializable;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class SynchronizedLazyImpl implements Lazy, Serializable {
+    public volatile Object _value;
+    public Function0 initializer;
+    public final Object lock;
+
+    public SynchronizedLazyImpl(Function0 initializer, Object obj) {
+        Intrinsics.checkNotNullParameter(initializer, "initializer");
+        this.initializer = initializer;
+        this._value = UNINITIALIZED_VALUE.INSTANCE;
+        this.lock = obj == null ? this : obj;
+    }
+
+    public /* synthetic */ SynchronizedLazyImpl(Function0 function0, Object obj, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(function0, (i & 2) != 0 ? null : obj);
+    }
+
+    @Override // kotlin.Lazy
+    public Object getValue() {
+        Object obj;
+        Object obj2 = this._value;
+        UNINITIALIZED_VALUE uninitialized_value = UNINITIALIZED_VALUE.INSTANCE;
+        if (obj2 != uninitialized_value) {
+            return obj2;
+        }
+        synchronized (this.lock) {
+            obj = this._value;
+            if (obj == uninitialized_value) {
+                Function0 function0 = this.initializer;
+                Intrinsics.checkNotNull(function0);
+                obj = function0.invoke();
+                this._value = obj;
+                this.initializer = null;
+            }
+        }
+        return obj;
+    }
+
+    @Override // kotlin.Lazy
+    public boolean isInitialized() {
+        return this._value != UNINITIALIZED_VALUE.INSTANCE;
+    }
+
+    public String toString() {
+        return isInitialized() ? String.valueOf(getValue()) : "Lazy value not initialized yet.";
+    }
+
+    private final Object writeReplace() {
+        return new InitializedLazyImpl(getValue());
+    }
+}

decompiled/sources/kotlin/TuplesKt.java

@@ -0,0 +1,8 @@
+package kotlin;
+
+/* loaded from: classes5.dex */
+public abstract class TuplesKt {
+    public static final Pair to(Object obj, Object obj2) {
+        return new Pair(obj, obj2);
+    }
+}

decompiled/sources/kotlin/ULong.java

@@ -0,0 +1,22 @@
+package kotlin;
+
+import kotlin.jvm.internal.DefaultConstructorMarker;
+
+/* loaded from: classes5.dex */
+public abstract class ULong implements Comparable {
+    public static final Companion Companion = new Companion(null);
+
+    /* renamed from: constructor-impl, reason: not valid java name */
+    public static long m4068constructorimpl(long j) {
+        return j;
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+}

decompiled/sources/kotlin/UNINITIALIZED_VALUE.java

@@ -0,0 +1,6 @@
+package kotlin;
+
+/* loaded from: classes5.dex */
+public final class UNINITIALIZED_VALUE {
+    public static final UNINITIALIZED_VALUE INSTANCE = new UNINITIALIZED_VALUE();
+}

decompiled/sources/kotlin/UninitializedPropertyAccessException.java

@@ -0,0 +1,8 @@
+package kotlin;
+
+/* loaded from: classes5.dex */
+public final class UninitializedPropertyAccessException extends RuntimeException {
+    public UninitializedPropertyAccessException(String str) {
+        super(str);
+    }
+}

decompiled/sources/kotlin/Unit.java

@@ -0,0 +1,10 @@
+package kotlin;
+
+/* loaded from: classes5.dex */
+public final class Unit {
+    public static final Unit INSTANCE = new Unit();
+
+    public String toString() {
+        return "kotlin.Unit";
+    }
+}

decompiled/sources/kotlin/UnsafeLazyImpl.java

@@ -0,0 +1,41 @@
+package kotlin;
+
+import java.io.Serializable;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class UnsafeLazyImpl implements Lazy, Serializable {
+    public Object _value;
+    public Function0 initializer;
+
+    public UnsafeLazyImpl(Function0 initializer) {
+        Intrinsics.checkNotNullParameter(initializer, "initializer");
+        this.initializer = initializer;
+        this._value = UNINITIALIZED_VALUE.INSTANCE;
+    }
+
+    @Override // kotlin.Lazy
+    public Object getValue() {
+        if (this._value == UNINITIALIZED_VALUE.INSTANCE) {
+            Function0 function0 = this.initializer;
+            Intrinsics.checkNotNull(function0);
+            this._value = function0.invoke();
+            this.initializer = null;
+        }
+        return this._value;
+    }
+
+    @Override // kotlin.Lazy
+    public boolean isInitialized() {
+        return this._value != UNINITIALIZED_VALUE.INSTANCE;
+    }
+
+    public String toString() {
+        return isInitialized() ? String.valueOf(getValue()) : "Lazy value not initialized yet.";
+    }
+
+    private final Object writeReplace() {
+        return new InitializedLazyImpl(getValue());
+    }
+}

decompiled/sources/kotlin/annotation/MustBeDocumented.java

@@ -0,0 +1,15 @@
+package kotlin.annotation;
+
+import com.facebook.ads.redexgen.core.EnumC1344dI;
+import com.fyber.inneractive.sdk.bidder.TokenParametersOuterClass$TokenParameters;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.RetentionPolicy;
+import kotlin.Metadata;
+
+@java.lang.annotation.Target({ElementType.ANNOTATION_TYPE})
+@Metadata(d1 = {"\u0000\n\n\u0002\u0018\u0002\n\u0002\u0010\u001b\n\u0000\b\u0087\u0002\u0018\u00002\u00020\u0001B\u0000¨\u0006\u0002"}, d2 = {"Lkotlin/annotation/MustBeDocumented;", "", "kotlin-stdlib"}, k = 1, mv = {1, 9, 0}, xi = TokenParametersOuterClass$TokenParameters.LOWPOWERMODE_FIELD_NUMBER)
+@Target(allowedTargets = {EnumC1344dI.A04})
+@java.lang.annotation.Retention(RetentionPolicy.RUNTIME)
+/* loaded from: assets/audience_network.dex */
+public @interface MustBeDocumented {
+}

decompiled/sources/kotlin/annotation/Retention.java

@@ -0,0 +1,16 @@
+package kotlin.annotation;
+
+import com.facebook.ads.redexgen.core.EnumC1344dI;
+import com.fyber.inneractive.sdk.bidder.TokenParametersOuterClass$TokenParameters;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.RetentionPolicy;
+import kotlin.Metadata;
+
+/* JADX WARN: Method from annotation default annotation not found: value */
+@java.lang.annotation.Target({ElementType.ANNOTATION_TYPE})
+@Metadata(d1 = {"\u0000\u0012\n\u0002\u0018\u0002\n\u0002\u0010\u001b\n\u0000\n\u0002\u0018\u0002\n\u0002\b\u0002\b\u0087\u0002\u0018\u00002\u00020\u0001B\n\u0012\b\b\u0002\u0010\u0002\u001a\u00020\u0003R\u000f\u0010\u0002\u001a\u00020\u0003¢\u0006\u0006\u001a\u0004\b\u0002\u0010\u0004¨\u0006\u0005"}, d2 = {"Lkotlin/annotation/Retention;", "", "value", "Lkotlin/annotation/AnnotationRetention;", "()Lkotlin/annotation/AnnotationRetention;", "kotlin-stdlib"}, k = 1, mv = {1, 9, 0}, xi = TokenParametersOuterClass$TokenParameters.LOWPOWERMODE_FIELD_NUMBER)
+@Target(allowedTargets = {EnumC1344dI.A04})
+@java.lang.annotation.Retention(RetentionPolicy.RUNTIME)
+/* loaded from: assets/audience_network.dex */
+public @interface Retention {
+}

decompiled/sources/kotlin/annotation/Target.java

@@ -0,0 +1,18 @@
+package kotlin.annotation;
+
+import com.facebook.ads.redexgen.core.EnumC1344dI;
+import com.fyber.inneractive.sdk.bidder.TokenParametersOuterClass$TokenParameters;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.RetentionPolicy;
+import kotlin.Metadata;
+
+@java.lang.annotation.Target({ElementType.ANNOTATION_TYPE})
+@MustBeDocumented
+@Metadata(d1 = {"\u0000\u0016\n\u0002\u0018\u0002\n\u0002\u0010\u001b\n\u0000\n\u0002\u0010\u0011\n\u0002\u0018\u0002\n\u0002\b\u0002\b\u0087\u0002\u0018\u00002\u00020\u0001B\u0014\u0012\u0012\u0010\u0002\u001a\n\u0012\u0006\b\u0001\u0012\u00020\u00040\u0003\"\u00020\u0004R\u0017\u0010\u0002\u001a\n\u0012\u0006\b\u0001\u0012\u00020\u00040\u0003¢\u0006\u0006\u001a\u0004\b\u0002\u0010\u0005¨\u0006\u0006"}, d2 = {"Lkotlin/annotation/Target;", "", "allowedTargets", "", "Lkotlin/annotation/AnnotationTarget;", "()[Lkotlin/annotation/AnnotationTarget;", "kotlin-stdlib"}, k = 1, mv = {1, 9, 0}, xi = TokenParametersOuterClass$TokenParameters.LOWPOWERMODE_FIELD_NUMBER)
+@Target(allowedTargets = {EnumC1344dI.A04})
+@Documented
+@java.lang.annotation.Retention(RetentionPolicy.RUNTIME)
+/* loaded from: assets/audience_network.dex */
+public @interface Target {
+}

decompiled/sources/kotlin/collections/AbstractCollection.java

@@ -0,0 +1,110 @@
+package kotlin.collections;
+
+import com.ironsource.v8;
+import java.util.Collection;
+import java.util.Iterator;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.CollectionToArray;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public abstract class AbstractCollection implements Collection, KMappedMarker {
+    @Override // java.util.Collection
+    public boolean add(Object obj) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Collection
+    public boolean addAll(Collection collection) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Collection
+    public void clear() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    public abstract int getSize();
+
+    @Override // java.util.Collection
+    public boolean remove(Object obj) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Collection
+    public boolean removeAll(Collection collection) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Collection
+    public boolean retainAll(Collection collection) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Collection
+    public final /* bridge */ int size() {
+        return getSize();
+    }
+
+    @Override // java.util.Collection
+    public boolean containsAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        Collection collection = elements;
+        if (collection.isEmpty()) {
+            return true;
+        }
+        Iterator it = collection.iterator();
+        while (it.hasNext()) {
+            if (!contains(it.next())) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // java.util.Collection
+    public boolean isEmpty() {
+        return size() == 0;
+    }
+
+    public String toString() {
+        String joinToString$default;
+        joinToString$default = CollectionsKt___CollectionsKt.joinToString$default(this, ", ", v8.i.d, v8.i.e, 0, null, new Function1() { // from class: kotlin.collections.AbstractCollection$toString$1
+            {
+                super(1);
+            }
+
+            @Override // kotlin.jvm.functions.Function1
+            public final CharSequence invoke(Object obj) {
+                return obj == AbstractCollection.this ? "(this Collection)" : String.valueOf(obj);
+            }
+        }, 24, null);
+        return joinToString$default;
+    }
+
+    @Override // java.util.Collection
+    public Object[] toArray() {
+        return CollectionToArray.toArray(this);
+    }
+
+    @Override // java.util.Collection
+    public Object[] toArray(Object[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        return CollectionToArray.toArray(this, array);
+    }
+
+    @Override // java.util.Collection
+    public boolean contains(Object obj) {
+        if (isEmpty()) {
+            return false;
+        }
+        Iterator<E> it = iterator();
+        while (it.hasNext()) {
+            if (Intrinsics.areEqual(it.next(), obj)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

decompiled/sources/kotlin/collections/AbstractIterator.java

@@ -0,0 +1,75 @@
+package kotlin.collections;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public abstract class AbstractIterator implements Iterator, KMappedMarker {
+    public Object nextValue;
+    public State state = State.NotReady;
+
+    public /* synthetic */ class WhenMappings {
+        public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+        static {
+            int[] iArr = new int[State.values().length];
+            try {
+                iArr[State.Done.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                iArr[State.Ready.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            $EnumSwitchMapping$0 = iArr;
+        }
+    }
+
+    public abstract void computeNext();
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        State state = this.state;
+        if (state == State.Failed) {
+            throw new IllegalArgumentException("Failed requirement.".toString());
+        }
+        int i = WhenMappings.$EnumSwitchMapping$0[state.ordinal()];
+        if (i == 1) {
+            return false;
+        }
+        if (i != 2) {
+            return tryToComputeNext();
+        }
+        return true;
+    }
+
+    @Override // java.util.Iterator
+    public Object next() {
+        if (!hasNext()) {
+            throw new NoSuchElementException();
+        }
+        this.state = State.NotReady;
+        return this.nextValue;
+    }
+
+    public final boolean tryToComputeNext() {
+        this.state = State.Failed;
+        computeNext();
+        return this.state == State.Ready;
+    }
+
+    public final void setNext(Object obj) {
+        this.nextValue = obj;
+        this.state = State.Ready;
+    }
+
+    public final void done() {
+        this.state = State.Done;
+    }
+}

decompiled/sources/kotlin/collections/AbstractList.java

@@ -0,0 +1,269 @@
+package kotlin.collections;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.NoSuchElementException;
+import java.util.RandomAccess;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public abstract class AbstractList extends AbstractCollection implements List, KMappedMarker {
+    public static final Companion Companion = new Companion(null);
+
+    @Override // java.util.List
+    public void add(int i, Object obj) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.List
+    public boolean addAll(int i, Collection collection) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.List
+    public abstract Object get(int i);
+
+    @Override // java.util.List
+    public Object remove(int i) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.List
+    public Object set(int i, Object obj) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Collection, java.lang.Iterable, java.util.List
+    public Iterator iterator() {
+        return new IteratorImpl();
+    }
+
+    @Override // java.util.List
+    public ListIterator listIterator() {
+        return new ListIteratorImpl(0);
+    }
+
+    @Override // java.util.List
+    public ListIterator listIterator(int i) {
+        return new ListIteratorImpl(i);
+    }
+
+    @Override // java.util.List
+    public List subList(int i, int i2) {
+        return new SubList(this, i, i2);
+    }
+
+    public static final class SubList extends AbstractList implements RandomAccess {
+        public int _size;
+        public final int fromIndex;
+        public final AbstractList list;
+
+        @Override // kotlin.collections.AbstractCollection
+        public int getSize() {
+            return this._size;
+        }
+
+        public SubList(AbstractList list, int i, int i2) {
+            Intrinsics.checkNotNullParameter(list, "list");
+            this.list = list;
+            this.fromIndex = i;
+            AbstractList.Companion.checkRangeIndexes$kotlin_stdlib(i, i2, list.size());
+            this._size = i2 - i;
+        }
+
+        @Override // kotlin.collections.AbstractList, java.util.List
+        public Object get(int i) {
+            AbstractList.Companion.checkElementIndex$kotlin_stdlib(i, this._size);
+            return this.list.get(this.fromIndex + i);
+        }
+    }
+
+    @Override // java.util.Collection, java.util.List
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof List) {
+            return Companion.orderedEquals$kotlin_stdlib(this, (Collection) obj);
+        }
+        return false;
+    }
+
+    @Override // java.util.Collection, java.util.List
+    public int hashCode() {
+        return Companion.orderedHashCode$kotlin_stdlib(this);
+    }
+
+    public class IteratorImpl implements Iterator, KMappedMarker {
+        public int index;
+
+        public final int getIndex() {
+            return this.index;
+        }
+
+        @Override // java.util.Iterator
+        public void remove() {
+            throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+        }
+
+        public final void setIndex(int i) {
+            this.index = i;
+        }
+
+        public IteratorImpl() {
+        }
+
+        @Override // java.util.Iterator
+        public boolean hasNext() {
+            return this.index < AbstractList.this.size();
+        }
+
+        @Override // java.util.Iterator
+        public Object next() {
+            if (!hasNext()) {
+                throw new NoSuchElementException();
+            }
+            AbstractList abstractList = AbstractList.this;
+            int i = this.index;
+            this.index = i + 1;
+            return abstractList.get(i);
+        }
+    }
+
+    public class ListIteratorImpl extends IteratorImpl implements ListIterator, KMappedMarker {
+        @Override // java.util.ListIterator
+        public void add(Object obj) {
+            throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+        }
+
+        @Override // java.util.ListIterator
+        public void set(Object obj) {
+            throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+        }
+
+        public ListIteratorImpl(int i) {
+            super();
+            AbstractList.Companion.checkPositionIndex$kotlin_stdlib(i, AbstractList.this.size());
+            setIndex(i);
+        }
+
+        @Override // java.util.ListIterator
+        public boolean hasPrevious() {
+            return getIndex() > 0;
+        }
+
+        @Override // java.util.ListIterator
+        public int nextIndex() {
+            return getIndex();
+        }
+
+        @Override // java.util.ListIterator
+        public Object previous() {
+            if (!hasPrevious()) {
+                throw new NoSuchElementException();
+            }
+            AbstractList abstractList = AbstractList.this;
+            setIndex(getIndex() - 1);
+            return abstractList.get(getIndex());
+        }
+
+        @Override // java.util.ListIterator
+        public int previousIndex() {
+            return getIndex() - 1;
+        }
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public final int newCapacity$kotlin_stdlib(int i, int i2) {
+            int i3 = i + (i >> 1);
+            if (i3 - i2 < 0) {
+                i3 = i2;
+            }
+            return i3 - 2147483639 > 0 ? i2 > 2147483639 ? Integer.MAX_VALUE : 2147483639 : i3;
+        }
+
+        public Companion() {
+        }
+
+        public final void checkElementIndex$kotlin_stdlib(int i, int i2) {
+            if (i < 0 || i >= i2) {
+                throw new IndexOutOfBoundsException("index: " + i + ", size: " + i2);
+            }
+        }
+
+        public final void checkPositionIndex$kotlin_stdlib(int i, int i2) {
+            if (i < 0 || i > i2) {
+                throw new IndexOutOfBoundsException("index: " + i + ", size: " + i2);
+            }
+        }
+
+        public final void checkRangeIndexes$kotlin_stdlib(int i, int i2, int i3) {
+            if (i < 0 || i2 > i3) {
+                throw new IndexOutOfBoundsException("fromIndex: " + i + ", toIndex: " + i2 + ", size: " + i3);
+            }
+            if (i <= i2) {
+                return;
+            }
+            throw new IllegalArgumentException("fromIndex: " + i + " > toIndex: " + i2);
+        }
+
+        public final int orderedHashCode$kotlin_stdlib(Collection c) {
+            Intrinsics.checkNotNullParameter(c, "c");
+            Iterator it = c.iterator();
+            int i = 1;
+            while (it.hasNext()) {
+                Object next = it.next();
+                i = (i * 31) + (next != null ? next.hashCode() : 0);
+            }
+            return i;
+        }
+
+        public final boolean orderedEquals$kotlin_stdlib(Collection c, Collection other) {
+            Intrinsics.checkNotNullParameter(c, "c");
+            Intrinsics.checkNotNullParameter(other, "other");
+            if (c.size() != other.size()) {
+                return false;
+            }
+            Iterator it = other.iterator();
+            Iterator it2 = c.iterator();
+            while (it2.hasNext()) {
+                if (!Intrinsics.areEqual(it2.next(), it.next())) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+
+    @Override // java.util.List
+    public int indexOf(Object obj) {
+        Iterator it = iterator();
+        int i = 0;
+        while (it.hasNext()) {
+            if (Intrinsics.areEqual(it.next(), obj)) {
+                return i;
+            }
+            i++;
+        }
+        return -1;
+    }
+
+    @Override // java.util.List
+    public int lastIndexOf(Object obj) {
+        ListIterator listIterator = listIterator(size());
+        while (listIterator.hasPrevious()) {
+            if (Intrinsics.areEqual(listIterator.previous(), obj)) {
+                return listIterator.nextIndex();
+            }
+        }
+        return -1;
+    }
+}

decompiled/sources/kotlin/collections/AbstractMutableCollection.java

@@ -0,0 +1,14 @@
+package kotlin.collections;
+
+import java.util.Collection;
+import kotlin.jvm.internal.markers.KMutableCollection;
+
+/* loaded from: classes5.dex */
+public abstract class AbstractMutableCollection extends java.util.AbstractCollection implements Collection, KMutableCollection {
+    public abstract int getSize();
+
+    @Override // java.util.AbstractCollection, java.util.Collection
+    public final /* bridge */ int size() {
+        return getSize();
+    }
+}

decompiled/sources/kotlin/collections/AbstractMutableList.java

@@ -0,0 +1,21 @@
+package kotlin.collections;
+
+import java.util.List;
+import kotlin.jvm.internal.markers.KMutableList;
+
+/* loaded from: classes5.dex */
+public abstract class AbstractMutableList extends java.util.AbstractList implements List, KMutableList {
+    public abstract int getSize();
+
+    public abstract Object removeAt(int i);
+
+    @Override // java.util.AbstractList, java.util.List
+    public final /* bridge */ Object remove(int i) {
+        return removeAt(i);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final /* bridge */ int size() {
+        return getSize();
+    }
+}

decompiled/sources/kotlin/collections/AbstractMutableSet.java

@@ -0,0 +1,15 @@
+package kotlin.collections;
+
+import java.util.AbstractSet;
+import java.util.Set;
+import kotlin.jvm.internal.markers.KMutableSet;
+
+/* loaded from: classes5.dex */
+public abstract class AbstractMutableSet extends AbstractSet implements Set, KMutableSet {
+    public abstract int getSize();
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public final /* bridge */ int size() {
+        return getSize();
+    }
+}

decompiled/sources/kotlin/collections/ArrayAsCollection.java

@@ -0,0 +1,103 @@
+package kotlin.collections;
+
+import java.util.Collection;
+import java.util.Iterator;
+import kotlin.jvm.internal.ArrayIteratorKt;
+import kotlin.jvm.internal.CollectionToArray;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public final class ArrayAsCollection implements Collection, KMappedMarker {
+    public final boolean isVarargs;
+    public final Object[] values;
+
+    @Override // java.util.Collection
+    public boolean add(Object obj) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Collection
+    public boolean addAll(Collection collection) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Collection
+    public void clear() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Collection
+    public boolean remove(Object obj) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Collection
+    public boolean removeAll(Collection collection) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Collection
+    public boolean retainAll(Collection collection) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Collection
+    public Object[] toArray(Object[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        return CollectionToArray.toArray(this, array);
+    }
+
+    public ArrayAsCollection(Object[] values, boolean z) {
+        Intrinsics.checkNotNullParameter(values, "values");
+        this.values = values;
+        this.isVarargs = z;
+    }
+
+    @Override // java.util.Collection
+    public final /* bridge */ int size() {
+        return getSize();
+    }
+
+    public int getSize() {
+        return this.values.length;
+    }
+
+    @Override // java.util.Collection
+    public boolean isEmpty() {
+        return this.values.length == 0;
+    }
+
+    @Override // java.util.Collection
+    public boolean contains(Object obj) {
+        boolean contains;
+        contains = ArraysKt___ArraysKt.contains(this.values, obj);
+        return contains;
+    }
+
+    @Override // java.util.Collection
+    public boolean containsAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        Collection collection = elements;
+        if (collection.isEmpty()) {
+            return true;
+        }
+        Iterator it = collection.iterator();
+        while (it.hasNext()) {
+            if (!contains(it.next())) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // java.util.Collection, java.lang.Iterable
+    public Iterator iterator() {
+        return ArrayIteratorKt.iterator(this.values);
+    }
+
+    @Override // java.util.Collection
+    public final Object[] toArray() {
+        return CollectionsKt__CollectionsJVMKt.copyToArrayOfAny(this.values, this.isVarargs);
+    }
+}

decompiled/sources/kotlin/collections/ArrayDeque.java

@@ -0,0 +1,610 @@
+package kotlin.collections;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.ranges.RangesKt___RangesKt;
+
+/* loaded from: classes5.dex */
+public final class ArrayDeque extends AbstractMutableList {
+    public static final Companion Companion = new Companion(null);
+    public static final Object[] emptyElementData = new Object[0];
+    public Object[] elementData = emptyElementData;
+    public int head;
+    public int size;
+
+    @Override // kotlin.collections.AbstractMutableList
+    public int getSize() {
+        return this.size;
+    }
+
+    private final void ensureCapacity(int i) {
+        int coerceAtLeast;
+        if (i < 0) {
+            throw new IllegalStateException("Deque is too big.");
+        }
+        Object[] objArr = this.elementData;
+        if (i <= objArr.length) {
+            return;
+        }
+        if (objArr == emptyElementData) {
+            coerceAtLeast = RangesKt___RangesKt.coerceAtLeast(i, 10);
+            this.elementData = new Object[coerceAtLeast];
+        } else {
+            copyElements(AbstractList.Companion.newCapacity$kotlin_stdlib(objArr.length, i));
+        }
+    }
+
+    public final void copyElements(int i) {
+        Object[] objArr = new Object[i];
+        Object[] objArr2 = this.elementData;
+        ArraysKt___ArraysJvmKt.copyInto(objArr2, objArr, 0, this.head, objArr2.length);
+        Object[] objArr3 = this.elementData;
+        int length = objArr3.length;
+        int i2 = this.head;
+        ArraysKt___ArraysJvmKt.copyInto(objArr3, objArr, length - i2, 0, i2);
+        this.head = 0;
+        this.elementData = objArr;
+    }
+
+    public final int positiveMod(int i) {
+        Object[] objArr = this.elementData;
+        return i >= objArr.length ? i - objArr.length : i;
+    }
+
+    public final int negativeMod(int i) {
+        return i < 0 ? i + this.elementData.length : i;
+    }
+
+    public final int incremented(int i) {
+        if (i == ArraysKt___ArraysKt.getLastIndex(this.elementData)) {
+            return 0;
+        }
+        return i + 1;
+    }
+
+    public final int decremented(int i) {
+        return i == 0 ? ArraysKt___ArraysKt.getLastIndex(this.elementData) : i - 1;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public boolean isEmpty() {
+        return size() == 0;
+    }
+
+    public final void addFirst(Object obj) {
+        ensureCapacity(size() + 1);
+        int decremented = decremented(this.head);
+        this.head = decremented;
+        this.elementData[decremented] = obj;
+        this.size = size() + 1;
+    }
+
+    public final void addLast(Object obj) {
+        ensureCapacity(size() + 1);
+        this.elementData[positiveMod(this.head + size())] = obj;
+        this.size = size() + 1;
+    }
+
+    public final Object removeFirst() {
+        if (isEmpty()) {
+            throw new NoSuchElementException("ArrayDeque is empty.");
+        }
+        Object[] objArr = this.elementData;
+        int i = this.head;
+        Object obj = objArr[i];
+        objArr[i] = null;
+        this.head = incremented(i);
+        this.size = size() - 1;
+        return obj;
+    }
+
+    public final Object removeFirstOrNull() {
+        if (isEmpty()) {
+            return null;
+        }
+        return removeFirst();
+    }
+
+    public final Object removeLast() {
+        if (isEmpty()) {
+            throw new NoSuchElementException("ArrayDeque is empty.");
+        }
+        int positiveMod = positiveMod(this.head + CollectionsKt__CollectionsKt.getLastIndex(this));
+        Object[] objArr = this.elementData;
+        Object obj = objArr[positiveMod];
+        objArr[positiveMod] = null;
+        this.size = size() - 1;
+        return obj;
+    }
+
+    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public boolean add(Object obj) {
+        addLast(obj);
+        return true;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public void add(int i, Object obj) {
+        AbstractList.Companion.checkPositionIndex$kotlin_stdlib(i, size());
+        if (i == size()) {
+            addLast(obj);
+            return;
+        }
+        if (i == 0) {
+            addFirst(obj);
+            return;
+        }
+        ensureCapacity(size() + 1);
+        int positiveMod = positiveMod(this.head + i);
+        if (i < ((size() + 1) >> 1)) {
+            int decremented = decremented(positiveMod);
+            int decremented2 = decremented(this.head);
+            int i2 = this.head;
+            if (decremented >= i2) {
+                Object[] objArr = this.elementData;
+                objArr[decremented2] = objArr[i2];
+                ArraysKt___ArraysJvmKt.copyInto(objArr, objArr, i2, i2 + 1, decremented + 1);
+            } else {
+                Object[] objArr2 = this.elementData;
+                ArraysKt___ArraysJvmKt.copyInto(objArr2, objArr2, i2 - 1, i2, objArr2.length);
+                Object[] objArr3 = this.elementData;
+                objArr3[objArr3.length - 1] = objArr3[0];
+                ArraysKt___ArraysJvmKt.copyInto(objArr3, objArr3, 0, 1, decremented + 1);
+            }
+            this.elementData[decremented] = obj;
+            this.head = decremented2;
+        } else {
+            int positiveMod2 = positiveMod(this.head + size());
+            if (positiveMod < positiveMod2) {
+                Object[] objArr4 = this.elementData;
+                ArraysKt___ArraysJvmKt.copyInto(objArr4, objArr4, positiveMod + 1, positiveMod, positiveMod2);
+            } else {
+                Object[] objArr5 = this.elementData;
+                ArraysKt___ArraysJvmKt.copyInto(objArr5, objArr5, 1, 0, positiveMod2);
+                Object[] objArr6 = this.elementData;
+                objArr6[0] = objArr6[objArr6.length - 1];
+                ArraysKt___ArraysJvmKt.copyInto(objArr6, objArr6, positiveMod + 1, positiveMod, objArr6.length - 1);
+            }
+            this.elementData[positiveMod] = obj;
+        }
+        this.size = size() + 1;
+    }
+
+    public final void copyCollectionElements(int i, Collection collection) {
+        Iterator it = collection.iterator();
+        int length = this.elementData.length;
+        while (i < length && it.hasNext()) {
+            this.elementData[i] = it.next();
+            i++;
+        }
+        int i2 = this.head;
+        for (int i3 = 0; i3 < i2 && it.hasNext(); i3++) {
+            this.elementData[i3] = it.next();
+        }
+        this.size = size() + collection.size();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public boolean addAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        if (elements.isEmpty()) {
+            return false;
+        }
+        ensureCapacity(size() + elements.size());
+        copyCollectionElements(positiveMod(this.head + size()), elements);
+        return true;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public boolean addAll(int i, Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        AbstractList.Companion.checkPositionIndex$kotlin_stdlib(i, size());
+        if (elements.isEmpty()) {
+            return false;
+        }
+        if (i == size()) {
+            return addAll(elements);
+        }
+        ensureCapacity(size() + elements.size());
+        int positiveMod = positiveMod(this.head + size());
+        int positiveMod2 = positiveMod(this.head + i);
+        int size = elements.size();
+        if (i < ((size() + 1) >> 1)) {
+            int i2 = this.head;
+            int i3 = i2 - size;
+            if (positiveMod2 < i2) {
+                Object[] objArr = this.elementData;
+                ArraysKt___ArraysJvmKt.copyInto(objArr, objArr, i3, i2, objArr.length);
+                if (size >= positiveMod2) {
+                    Object[] objArr2 = this.elementData;
+                    ArraysKt___ArraysJvmKt.copyInto(objArr2, objArr2, objArr2.length - size, 0, positiveMod2);
+                } else {
+                    Object[] objArr3 = this.elementData;
+                    ArraysKt___ArraysJvmKt.copyInto(objArr3, objArr3, objArr3.length - size, 0, size);
+                    Object[] objArr4 = this.elementData;
+                    ArraysKt___ArraysJvmKt.copyInto(objArr4, objArr4, 0, size, positiveMod2);
+                }
+            } else if (i3 >= 0) {
+                Object[] objArr5 = this.elementData;
+                ArraysKt___ArraysJvmKt.copyInto(objArr5, objArr5, i3, i2, positiveMod2);
+            } else {
+                Object[] objArr6 = this.elementData;
+                i3 += objArr6.length;
+                int i4 = positiveMod2 - i2;
+                int length = objArr6.length - i3;
+                if (length >= i4) {
+                    ArraysKt___ArraysJvmKt.copyInto(objArr6, objArr6, i3, i2, positiveMod2);
+                } else {
+                    ArraysKt___ArraysJvmKt.copyInto(objArr6, objArr6, i3, i2, i2 + length);
+                    Object[] objArr7 = this.elementData;
+                    ArraysKt___ArraysJvmKt.copyInto(objArr7, objArr7, 0, this.head + length, positiveMod2);
+                }
+            }
+            this.head = i3;
+            copyCollectionElements(negativeMod(positiveMod2 - size), elements);
+        } else {
+            int i5 = positiveMod2 + size;
+            if (positiveMod2 < positiveMod) {
+                int i6 = size + positiveMod;
+                Object[] objArr8 = this.elementData;
+                if (i6 <= objArr8.length) {
+                    ArraysKt___ArraysJvmKt.copyInto(objArr8, objArr8, i5, positiveMod2, positiveMod);
+                } else if (i5 >= objArr8.length) {
+                    ArraysKt___ArraysJvmKt.copyInto(objArr8, objArr8, i5 - objArr8.length, positiveMod2, positiveMod);
+                } else {
+                    int length2 = positiveMod - (i6 - objArr8.length);
+                    ArraysKt___ArraysJvmKt.copyInto(objArr8, objArr8, 0, length2, positiveMod);
+                    Object[] objArr9 = this.elementData;
+                    ArraysKt___ArraysJvmKt.copyInto(objArr9, objArr9, i5, positiveMod2, length2);
+                }
+            } else {
+                Object[] objArr10 = this.elementData;
+                ArraysKt___ArraysJvmKt.copyInto(objArr10, objArr10, size, 0, positiveMod);
+                Object[] objArr11 = this.elementData;
+                if (i5 >= objArr11.length) {
+                    ArraysKt___ArraysJvmKt.copyInto(objArr11, objArr11, i5 - objArr11.length, positiveMod2, objArr11.length);
+                } else {
+                    ArraysKt___ArraysJvmKt.copyInto(objArr11, objArr11, 0, objArr11.length - size, objArr11.length);
+                    Object[] objArr12 = this.elementData;
+                    ArraysKt___ArraysJvmKt.copyInto(objArr12, objArr12, i5, positiveMod2, objArr12.length - size);
+                }
+            }
+            copyCollectionElements(positiveMod2, elements);
+        }
+        return true;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public Object get(int i) {
+        AbstractList.Companion.checkElementIndex$kotlin_stdlib(i, size());
+        return this.elementData[positiveMod(this.head + i)];
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public Object set(int i, Object obj) {
+        AbstractList.Companion.checkElementIndex$kotlin_stdlib(i, size());
+        int positiveMod = positiveMod(this.head + i);
+        Object[] objArr = this.elementData;
+        Object obj2 = objArr[positiveMod];
+        objArr[positiveMod] = obj;
+        return obj2;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public boolean contains(Object obj) {
+        return indexOf(obj) != -1;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public int indexOf(Object obj) {
+        int i;
+        int positiveMod = positiveMod(this.head + size());
+        int i2 = this.head;
+        if (i2 < positiveMod) {
+            while (i2 < positiveMod) {
+                if (Intrinsics.areEqual(obj, this.elementData[i2])) {
+                    i = this.head;
+                } else {
+                    i2++;
+                }
+            }
+            return -1;
+        }
+        if (i2 < positiveMod) {
+            return -1;
+        }
+        int length = this.elementData.length;
+        while (true) {
+            if (i2 >= length) {
+                for (int i3 = 0; i3 < positiveMod; i3++) {
+                    if (Intrinsics.areEqual(obj, this.elementData[i3])) {
+                        i2 = i3 + this.elementData.length;
+                        i = this.head;
+                    }
+                }
+                return -1;
+            }
+            if (Intrinsics.areEqual(obj, this.elementData[i2])) {
+                i = this.head;
+                break;
+            }
+            i2++;
+        }
+        return i2 - i;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public int lastIndexOf(Object obj) {
+        int lastIndex;
+        int i;
+        int positiveMod = positiveMod(this.head + size());
+        int i2 = this.head;
+        if (i2 < positiveMod) {
+            lastIndex = positiveMod - 1;
+            if (i2 <= lastIndex) {
+                while (!Intrinsics.areEqual(obj, this.elementData[lastIndex])) {
+                    if (lastIndex != i2) {
+                        lastIndex--;
+                    }
+                }
+                i = this.head;
+                return lastIndex - i;
+            }
+            return -1;
+        }
+        if (i2 > positiveMod) {
+            int i3 = positiveMod - 1;
+            while (true) {
+                if (-1 < i3) {
+                    if (Intrinsics.areEqual(obj, this.elementData[i3])) {
+                        lastIndex = i3 + this.elementData.length;
+                        i = this.head;
+                        break;
+                    }
+                    i3--;
+                } else {
+                    lastIndex = ArraysKt___ArraysKt.getLastIndex(this.elementData);
+                    int i4 = this.head;
+                    if (i4 <= lastIndex) {
+                        while (!Intrinsics.areEqual(obj, this.elementData[lastIndex])) {
+                            if (lastIndex != i4) {
+                                lastIndex--;
+                            }
+                        }
+                        i = this.head;
+                    }
+                }
+            }
+        }
+        return -1;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public boolean remove(Object obj) {
+        int indexOf = indexOf(obj);
+        if (indexOf == -1) {
+            return false;
+        }
+        remove(indexOf);
+        return true;
+    }
+
+    @Override // kotlin.collections.AbstractMutableList
+    public Object removeAt(int i) {
+        AbstractList.Companion.checkElementIndex$kotlin_stdlib(i, size());
+        if (i == CollectionsKt__CollectionsKt.getLastIndex(this)) {
+            return removeLast();
+        }
+        if (i == 0) {
+            return removeFirst();
+        }
+        int positiveMod = positiveMod(this.head + i);
+        Object obj = this.elementData[positiveMod];
+        if (i < (size() >> 1)) {
+            int i2 = this.head;
+            if (positiveMod >= i2) {
+                Object[] objArr = this.elementData;
+                ArraysKt___ArraysJvmKt.copyInto(objArr, objArr, i2 + 1, i2, positiveMod);
+            } else {
+                Object[] objArr2 = this.elementData;
+                ArraysKt___ArraysJvmKt.copyInto(objArr2, objArr2, 1, 0, positiveMod);
+                Object[] objArr3 = this.elementData;
+                objArr3[0] = objArr3[objArr3.length - 1];
+                int i3 = this.head;
+                ArraysKt___ArraysJvmKt.copyInto(objArr3, objArr3, i3 + 1, i3, objArr3.length - 1);
+            }
+            Object[] objArr4 = this.elementData;
+            int i4 = this.head;
+            objArr4[i4] = null;
+            this.head = incremented(i4);
+        } else {
+            int positiveMod2 = positiveMod(this.head + CollectionsKt__CollectionsKt.getLastIndex(this));
+            if (positiveMod <= positiveMod2) {
+                Object[] objArr5 = this.elementData;
+                ArraysKt___ArraysJvmKt.copyInto(objArr5, objArr5, positiveMod, positiveMod + 1, positiveMod2 + 1);
+            } else {
+                Object[] objArr6 = this.elementData;
+                ArraysKt___ArraysJvmKt.copyInto(objArr6, objArr6, positiveMod, positiveMod + 1, objArr6.length);
+                Object[] objArr7 = this.elementData;
+                objArr7[objArr7.length - 1] = objArr7[0];
+                ArraysKt___ArraysJvmKt.copyInto(objArr7, objArr7, 0, 1, positiveMod2 + 1);
+            }
+            this.elementData[positiveMod2] = null;
+        }
+        this.size = size() - 1;
+        return obj;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public boolean removeAll(Collection elements) {
+        int positiveMod;
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        boolean z = false;
+        z = false;
+        z = false;
+        if (!isEmpty() && this.elementData.length != 0) {
+            int positiveMod2 = positiveMod(this.head + size());
+            int i = this.head;
+            if (i < positiveMod2) {
+                positiveMod = i;
+                while (i < positiveMod2) {
+                    Object obj = this.elementData[i];
+                    if (!elements.contains(obj)) {
+                        this.elementData[positiveMod] = obj;
+                        positiveMod++;
+                    } else {
+                        z = true;
+                    }
+                    i++;
+                }
+                ArraysKt___ArraysJvmKt.fill(this.elementData, (Object) null, positiveMod, positiveMod2);
+            } else {
+                int length = this.elementData.length;
+                boolean z2 = false;
+                int i2 = i;
+                while (i < length) {
+                    Object[] objArr = this.elementData;
+                    Object obj2 = objArr[i];
+                    objArr[i] = null;
+                    if (!elements.contains(obj2)) {
+                        this.elementData[i2] = obj2;
+                        i2++;
+                    } else {
+                        z2 = true;
+                    }
+                    i++;
+                }
+                positiveMod = positiveMod(i2);
+                for (int i3 = 0; i3 < positiveMod2; i3++) {
+                    Object[] objArr2 = this.elementData;
+                    Object obj3 = objArr2[i3];
+                    objArr2[i3] = null;
+                    if (!elements.contains(obj3)) {
+                        this.elementData[positiveMod] = obj3;
+                        positiveMod = incremented(positiveMod);
+                    } else {
+                        z2 = true;
+                    }
+                }
+                z = z2;
+            }
+            if (z) {
+                this.size = negativeMod(positiveMod - this.head);
+            }
+        }
+        return z;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public boolean retainAll(Collection elements) {
+        int positiveMod;
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        boolean z = false;
+        z = false;
+        z = false;
+        if (!isEmpty() && this.elementData.length != 0) {
+            int positiveMod2 = positiveMod(this.head + size());
+            int i = this.head;
+            if (i < positiveMod2) {
+                positiveMod = i;
+                while (i < positiveMod2) {
+                    Object obj = this.elementData[i];
+                    if (elements.contains(obj)) {
+                        this.elementData[positiveMod] = obj;
+                        positiveMod++;
+                    } else {
+                        z = true;
+                    }
+                    i++;
+                }
+                ArraysKt___ArraysJvmKt.fill(this.elementData, (Object) null, positiveMod, positiveMod2);
+            } else {
+                int length = this.elementData.length;
+                boolean z2 = false;
+                int i2 = i;
+                while (i < length) {
+                    Object[] objArr = this.elementData;
+                    Object obj2 = objArr[i];
+                    objArr[i] = null;
+                    if (elements.contains(obj2)) {
+                        this.elementData[i2] = obj2;
+                        i2++;
+                    } else {
+                        z2 = true;
+                    }
+                    i++;
+                }
+                positiveMod = positiveMod(i2);
+                for (int i3 = 0; i3 < positiveMod2; i3++) {
+                    Object[] objArr2 = this.elementData;
+                    Object obj3 = objArr2[i3];
+                    objArr2[i3] = null;
+                    if (elements.contains(obj3)) {
+                        this.elementData[positiveMod] = obj3;
+                        positiveMod = incremented(positiveMod);
+                    } else {
+                        z2 = true;
+                    }
+                }
+                z = z2;
+            }
+            if (z) {
+                this.size = negativeMod(positiveMod - this.head);
+            }
+        }
+        return z;
+    }
+
+    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public void clear() {
+        int positiveMod = positiveMod(this.head + size());
+        int i = this.head;
+        if (i < positiveMod) {
+            ArraysKt___ArraysJvmKt.fill(this.elementData, (Object) null, i, positiveMod);
+        } else if (!isEmpty()) {
+            Object[] objArr = this.elementData;
+            ArraysKt___ArraysJvmKt.fill(objArr, (Object) null, this.head, objArr.length);
+            ArraysKt___ArraysJvmKt.fill(this.elementData, (Object) null, 0, positiveMod);
+        }
+        this.head = 0;
+        this.size = 0;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public Object[] toArray(Object[] array) {
+        Object[] terminateCollectionToArray;
+        Intrinsics.checkNotNullParameter(array, "array");
+        if (array.length < size()) {
+            array = ArraysKt__ArraysJVMKt.arrayOfNulls(array, size());
+        }
+        int positiveMod = positiveMod(this.head + size());
+        int i = this.head;
+        if (i < positiveMod) {
+            ArraysKt___ArraysJvmKt.copyInto$default(this.elementData, array, 0, i, positiveMod, 2, (Object) null);
+        } else if (!isEmpty()) {
+            Object[] objArr = this.elementData;
+            ArraysKt___ArraysJvmKt.copyInto(objArr, array, 0, this.head, objArr.length);
+            Object[] objArr2 = this.elementData;
+            ArraysKt___ArraysJvmKt.copyInto(objArr2, array, objArr2.length - this.head, 0, positiveMod);
+        }
+        terminateCollectionToArray = CollectionsKt__CollectionsJVMKt.terminateCollectionToArray(size(), array);
+        return terminateCollectionToArray;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public Object[] toArray() {
+        return toArray(new Object[size()]);
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+}

decompiled/sources/kotlin/collections/ArraysKt.java

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

decompiled/sources/kotlin/collections/ArraysKt__ArraysJVMKt.java

@@ -0,0 +1,26 @@
+package kotlin.collections;
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class ArraysKt__ArraysJVMKt {
+    public static final Object[] arrayOfNulls(Object[] reference, int i) {
+        Intrinsics.checkNotNullParameter(reference, "reference");
+        Object newInstance = Array.newInstance(reference.getClass().getComponentType(), i);
+        Intrinsics.checkNotNull(newInstance, "null cannot be cast to non-null type kotlin.Array<T of kotlin.collections.ArraysKt__ArraysJVMKt.arrayOfNulls>");
+        return (Object[]) newInstance;
+    }
+
+    public static final void copyOfRangeToIndexCheck(int i, int i2) {
+        if (i <= i2) {
+            return;
+        }
+        throw new IndexOutOfBoundsException("toIndex (" + i + ") is greater than size (" + i2 + ").");
+    }
+
+    public static int contentDeepHashCode(Object[] objArr) {
+        return Arrays.deepHashCode(objArr);
+    }
+}

decompiled/sources/kotlin/collections/ArraysKt__ArraysKt.java

@@ -0,0 +1,68 @@
+package kotlin.collections;
+
+import java.util.Arrays;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class ArraysKt__ArraysKt extends ArraysKt__ArraysJVMKt {
+    public static boolean contentDeepEquals(Object[] objArr, Object[] objArr2) {
+        boolean contentDeepEquals;
+        if (objArr == objArr2) {
+            return true;
+        }
+        if (objArr == null || objArr2 == null || objArr.length != objArr2.length) {
+            return false;
+        }
+        int length = objArr.length;
+        for (int i = 0; i < length; i++) {
+            Object obj = objArr[i];
+            Object obj2 = objArr2[i];
+            if (obj != obj2) {
+                if (obj == null || obj2 == null) {
+                    return false;
+                }
+                if ((obj instanceof Object[]) && (obj2 instanceof Object[])) {
+                    contentDeepEquals = contentDeepEquals((Object[]) obj, (Object[]) obj2);
+                    if (!contentDeepEquals) {
+                        return false;
+                    }
+                } else if ((obj instanceof byte[]) && (obj2 instanceof byte[])) {
+                    if (!Arrays.equals((byte[]) obj, (byte[]) obj2)) {
+                        return false;
+                    }
+                } else if ((obj instanceof short[]) && (obj2 instanceof short[])) {
+                    if (!Arrays.equals((short[]) obj, (short[]) obj2)) {
+                        return false;
+                    }
+                } else if ((obj instanceof int[]) && (obj2 instanceof int[])) {
+                    if (!Arrays.equals((int[]) obj, (int[]) obj2)) {
+                        return false;
+                    }
+                } else if ((obj instanceof long[]) && (obj2 instanceof long[])) {
+                    if (!Arrays.equals((long[]) obj, (long[]) obj2)) {
+                        return false;
+                    }
+                } else if ((obj instanceof float[]) && (obj2 instanceof float[])) {
+                    if (!Arrays.equals((float[]) obj, (float[]) obj2)) {
+                        return false;
+                    }
+                } else if ((obj instanceof double[]) && (obj2 instanceof double[])) {
+                    if (!Arrays.equals((double[]) obj, (double[]) obj2)) {
+                        return false;
+                    }
+                } else if ((obj instanceof char[]) && (obj2 instanceof char[])) {
+                    if (!Arrays.equals((char[]) obj, (char[]) obj2)) {
+                        return false;
+                    }
+                } else if ((obj instanceof boolean[]) && (obj2 instanceof boolean[])) {
+                    if (!Arrays.equals((boolean[]) obj, (boolean[]) obj2)) {
+                        return false;
+                    }
+                } else if (!Intrinsics.areEqual(obj, obj2)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}

decompiled/sources/kotlin/collections/ArraysKt___ArraysJvmKt.java

@@ -0,0 +1,188 @@
+package kotlin.collections;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class ArraysKt___ArraysJvmKt extends ArraysKt__ArraysKt {
+    public static List asList(Object[] objArr) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        List asList = ArraysUtilJVM.asList(objArr);
+        Intrinsics.checkNotNullExpressionValue(asList, "asList(...)");
+        return asList;
+    }
+
+    public static /* synthetic */ Object[] copyInto$default(Object[] objArr, Object[] objArr2, int i, int i2, int i3, int i4, Object obj) {
+        if ((i4 & 2) != 0) {
+            i = 0;
+        }
+        if ((i4 & 4) != 0) {
+            i2 = 0;
+        }
+        if ((i4 & 8) != 0) {
+            i3 = objArr.length;
+        }
+        return copyInto(objArr, objArr2, i, i2, i3);
+    }
+
+    public static Object[] copyInto(Object[] objArr, Object[] destination, int i, int i2, int i3) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        Intrinsics.checkNotNullParameter(destination, "destination");
+        System.arraycopy(objArr, i2, destination, i, i3 - i2);
+        return destination;
+    }
+
+    public static /* synthetic */ int[] copyInto$default(int[] iArr, int[] iArr2, int i, int i2, int i3, int i4, Object obj) {
+        if ((i4 & 2) != 0) {
+            i = 0;
+        }
+        if ((i4 & 4) != 0) {
+            i2 = 0;
+        }
+        if ((i4 & 8) != 0) {
+            i3 = iArr.length;
+        }
+        return copyInto(iArr, iArr2, i, i2, i3);
+    }
+
+    public static int[] copyInto(int[] iArr, int[] destination, int i, int i2, int i3) {
+        Intrinsics.checkNotNullParameter(iArr, "<this>");
+        Intrinsics.checkNotNullParameter(destination, "destination");
+        System.arraycopy(iArr, i2, destination, i, i3 - i2);
+        return destination;
+    }
+
+    public static /* synthetic */ long[] copyInto$default(long[] jArr, long[] jArr2, int i, int i2, int i3, int i4, Object obj) {
+        if ((i4 & 2) != 0) {
+            i = 0;
+        }
+        if ((i4 & 4) != 0) {
+            i2 = 0;
+        }
+        if ((i4 & 8) != 0) {
+            i3 = jArr.length;
+        }
+        return copyInto(jArr, jArr2, i, i2, i3);
+    }
+
+    public static long[] copyInto(long[] jArr, long[] destination, int i, int i2, int i3) {
+        Intrinsics.checkNotNullParameter(jArr, "<this>");
+        Intrinsics.checkNotNullParameter(destination, "destination");
+        System.arraycopy(jArr, i2, destination, i, i3 - i2);
+        return destination;
+    }
+
+    public static /* synthetic */ float[] copyInto$default(float[] fArr, float[] fArr2, int i, int i2, int i3, int i4, Object obj) {
+        if ((i4 & 2) != 0) {
+            i = 0;
+        }
+        if ((i4 & 4) != 0) {
+            i2 = 0;
+        }
+        if ((i4 & 8) != 0) {
+            i3 = fArr.length;
+        }
+        return copyInto(fArr, fArr2, i, i2, i3);
+    }
+
+    public static float[] copyInto(float[] fArr, float[] destination, int i, int i2, int i3) {
+        Intrinsics.checkNotNullParameter(fArr, "<this>");
+        Intrinsics.checkNotNullParameter(destination, "destination");
+        System.arraycopy(fArr, i2, destination, i, i3 - i2);
+        return destination;
+    }
+
+    public static Object[] copyOfRange(Object[] objArr, int i, int i2) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        ArraysKt__ArraysJVMKt.copyOfRangeToIndexCheck(i2, objArr.length);
+        Object[] copyOfRange = Arrays.copyOfRange(objArr, i, i2);
+        Intrinsics.checkNotNullExpressionValue(copyOfRange, "copyOfRange(...)");
+        return copyOfRange;
+    }
+
+    public static final byte[] copyOfRange(byte[] bArr, int i, int i2) {
+        Intrinsics.checkNotNullParameter(bArr, "<this>");
+        ArraysKt__ArraysJVMKt.copyOfRangeToIndexCheck(i2, bArr.length);
+        byte[] copyOfRange = Arrays.copyOfRange(bArr, i, i2);
+        Intrinsics.checkNotNullExpressionValue(copyOfRange, "copyOfRange(...)");
+        return copyOfRange;
+    }
+
+    public static /* synthetic */ void fill$default(Object[] objArr, Object obj, int i, int i2, int i3, Object obj2) {
+        if ((i3 & 2) != 0) {
+            i = 0;
+        }
+        if ((i3 & 4) != 0) {
+            i2 = objArr.length;
+        }
+        fill(objArr, obj, i, i2);
+    }
+
+    public static void fill(Object[] objArr, Object obj, int i, int i2) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        Arrays.fill(objArr, i, i2, obj);
+    }
+
+    public static void fill(int[] iArr, int i, int i2, int i3) {
+        Intrinsics.checkNotNullParameter(iArr, "<this>");
+        Arrays.fill(iArr, i2, i3, i);
+    }
+
+    public static /* synthetic */ void fill$default(long[] jArr, long j, int i, int i2, int i3, Object obj) {
+        if ((i3 & 2) != 0) {
+            i = 0;
+        }
+        if ((i3 & 4) != 0) {
+            i2 = jArr.length;
+        }
+        fill(jArr, j, i, i2);
+    }
+
+    public static final void fill(long[] jArr, long j, int i, int i2) {
+        Intrinsics.checkNotNullParameter(jArr, "<this>");
+        Arrays.fill(jArr, i, i2, j);
+    }
+
+    public static byte[] plus(byte[] bArr, byte[] elements) {
+        Intrinsics.checkNotNullParameter(bArr, "<this>");
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        int length = bArr.length;
+        int length2 = elements.length;
+        byte[] copyOf = Arrays.copyOf(bArr, length + length2);
+        System.arraycopy(elements, 0, copyOf, length, length2);
+        Intrinsics.checkNotNull(copyOf);
+        return copyOf;
+    }
+
+    public static void sort(Object[] objArr) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        if (objArr.length > 1) {
+            Arrays.sort(objArr);
+        }
+    }
+
+    public static void sort(int[] iArr, int i, int i2) {
+        Intrinsics.checkNotNullParameter(iArr, "<this>");
+        Arrays.sort(iArr, i, i2);
+    }
+
+    public static void sort(long[] jArr, int i, int i2) {
+        Intrinsics.checkNotNullParameter(jArr, "<this>");
+        Arrays.sort(jArr, i, i2);
+    }
+
+    public static void sort(float[] fArr, int i, int i2) {
+        Intrinsics.checkNotNullParameter(fArr, "<this>");
+        Arrays.sort(fArr, i, i2);
+    }
+
+    public static final void sortWith(Object[] objArr, Comparator comparator) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        Intrinsics.checkNotNullParameter(comparator, "comparator");
+        if (objArr.length > 1) {
+            Arrays.sort(objArr, comparator);
+        }
+    }
+}

decompiled/sources/kotlin/collections/ArraysKt___ArraysKt.java

@@ -0,0 +1,366 @@
+package kotlin.collections;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.ranges.IntRange;
+import kotlin.text.StringsKt__AppendableKt;
+
+/* loaded from: classes5.dex */
+public abstract class ArraysKt___ArraysKt extends ArraysKt___ArraysJvmKt {
+    public static boolean contains(Object[] objArr, Object obj) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        return indexOf(objArr, obj) >= 0;
+    }
+
+    public static boolean contains(char[] cArr, char c) {
+        Intrinsics.checkNotNullParameter(cArr, "<this>");
+        return indexOf(cArr, c) >= 0;
+    }
+
+    public static Object first(Object[] objArr) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        if (objArr.length == 0) {
+            throw new NoSuchElementException("Array is empty.");
+        }
+        return objArr[0];
+    }
+
+    public static Object getOrNull(Object[] objArr, int i) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        if (i < 0 || i > getLastIndex(objArr)) {
+            return null;
+        }
+        return objArr[i];
+    }
+
+    public static int indexOf(Object[] objArr, Object obj) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        int i = 0;
+        if (obj == null) {
+            int length = objArr.length;
+            while (i < length) {
+                if (objArr[i] == null) {
+                    return i;
+                }
+                i++;
+            }
+            return -1;
+        }
+        int length2 = objArr.length;
+        while (i < length2) {
+            if (Intrinsics.areEqual(obj, objArr[i])) {
+                return i;
+            }
+            i++;
+        }
+        return -1;
+    }
+
+    public static final int indexOf(char[] cArr, char c) {
+        Intrinsics.checkNotNullParameter(cArr, "<this>");
+        int length = cArr.length;
+        for (int i = 0; i < length; i++) {
+            if (c == cArr[i]) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    public static char single(char[] cArr) {
+        Intrinsics.checkNotNullParameter(cArr, "<this>");
+        int length = cArr.length;
+        if (length == 0) {
+            throw new NoSuchElementException("Array is empty.");
+        }
+        if (length == 1) {
+            return cArr[0];
+        }
+        throw new IllegalArgumentException("Array has more than one element.");
+    }
+
+    public static Object singleOrNull(Object[] objArr) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        if (objArr.length == 1) {
+            return objArr[0];
+        }
+        return null;
+    }
+
+    public static List filterNotNull(Object[] objArr) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        return (List) filterNotNullTo(objArr, new ArrayList());
+    }
+
+    public static final Collection filterNotNullTo(Object[] objArr, Collection destination) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        Intrinsics.checkNotNullParameter(destination, "destination");
+        for (Object obj : objArr) {
+            if (obj != null) {
+                destination.add(obj);
+            }
+        }
+        return destination;
+    }
+
+    public static byte[] sliceArray(byte[] bArr, IntRange indices) {
+        Intrinsics.checkNotNullParameter(bArr, "<this>");
+        Intrinsics.checkNotNullParameter(indices, "indices");
+        return indices.isEmpty() ? new byte[0] : ArraysKt___ArraysJvmKt.copyOfRange(bArr, indices.getStart().intValue(), indices.getEndInclusive().intValue() + 1);
+    }
+
+    public static final void reverse(int[] iArr, int i, int i2) {
+        Intrinsics.checkNotNullParameter(iArr, "<this>");
+        AbstractList.Companion.checkRangeIndexes$kotlin_stdlib(i, i2, iArr.length);
+        int i3 = (i + i2) / 2;
+        if (i == i3) {
+            return;
+        }
+        int i4 = i2 - 1;
+        while (i < i3) {
+            int i5 = iArr[i];
+            iArr[i] = iArr[i4];
+            iArr[i4] = i5;
+            i4--;
+            i++;
+        }
+    }
+
+    public static final void reverse(long[] jArr, int i, int i2) {
+        Intrinsics.checkNotNullParameter(jArr, "<this>");
+        AbstractList.Companion.checkRangeIndexes$kotlin_stdlib(i, i2, jArr.length);
+        int i3 = (i + i2) / 2;
+        if (i == i3) {
+            return;
+        }
+        int i4 = i2 - 1;
+        while (i < i3) {
+            long j = jArr[i];
+            jArr[i] = jArr[i4];
+            jArr[i4] = j;
+            i4--;
+            i++;
+        }
+    }
+
+    public static final void reverse(float[] fArr, int i, int i2) {
+        Intrinsics.checkNotNullParameter(fArr, "<this>");
+        AbstractList.Companion.checkRangeIndexes$kotlin_stdlib(i, i2, fArr.length);
+        int i3 = (i + i2) / 2;
+        if (i == i3) {
+            return;
+        }
+        int i4 = i2 - 1;
+        while (i < i3) {
+            float f = fArr[i];
+            fArr[i] = fArr[i4];
+            fArr[i4] = f;
+            i4--;
+            i++;
+        }
+    }
+
+    public static final int getLastIndex(Object[] objArr) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        return objArr.length - 1;
+    }
+
+    public static int getLastIndex(int[] iArr) {
+        Intrinsics.checkNotNullParameter(iArr, "<this>");
+        return iArr.length - 1;
+    }
+
+    public static void sortDescending(int[] iArr, int i, int i2) {
+        Intrinsics.checkNotNullParameter(iArr, "<this>");
+        ArraysKt___ArraysJvmKt.sort(iArr, i, i2);
+        reverse(iArr, i, i2);
+    }
+
+    public static void sortDescending(long[] jArr, int i, int i2) {
+        Intrinsics.checkNotNullParameter(jArr, "<this>");
+        ArraysKt___ArraysJvmKt.sort(jArr, i, i2);
+        reverse(jArr, i, i2);
+    }
+
+    public static void sortDescending(float[] fArr, int i, int i2) {
+        Intrinsics.checkNotNullParameter(fArr, "<this>");
+        ArraysKt___ArraysJvmKt.sort(fArr, i, i2);
+        reverse(fArr, i, i2);
+    }
+
+    public static final Collection toCollection(Object[] objArr, Collection destination) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        Intrinsics.checkNotNullParameter(destination, "destination");
+        for (Object obj : objArr) {
+            destination.add(obj);
+        }
+        return destination;
+    }
+
+    public static HashSet toHashSet(Object[] objArr) {
+        int mapCapacity;
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        mapCapacity = MapsKt__MapsJVMKt.mapCapacity(objArr.length);
+        return (HashSet) toCollection(objArr, new HashSet(mapCapacity));
+    }
+
+    public static List toList(Object[] objArr) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        int length = objArr.length;
+        if (length == 0) {
+            return CollectionsKt__CollectionsKt.emptyList();
+        }
+        if (length == 1) {
+            return CollectionsKt__CollectionsJVMKt.listOf(objArr[0]);
+        }
+        return toMutableList(objArr);
+    }
+
+    public static List toMutableList(Object[] objArr) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        return new ArrayList(CollectionsKt__CollectionsKt.asCollection(objArr));
+    }
+
+    public static Set toSet(Object[] objArr) {
+        Set emptySet;
+        Set of;
+        int mapCapacity;
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        int length = objArr.length;
+        if (length == 0) {
+            emptySet = SetsKt__SetsKt.emptySet();
+            return emptySet;
+        }
+        if (length == 1) {
+            of = SetsKt__SetsJVMKt.setOf(objArr[0]);
+            return of;
+        }
+        mapCapacity = MapsKt__MapsJVMKt.mapCapacity(objArr.length);
+        return (Set) toCollection(objArr, new LinkedHashSet(mapCapacity));
+    }
+
+    public static final Appendable joinTo(Object[] objArr, Appendable buffer, CharSequence separator, CharSequence prefix, CharSequence postfix, int i, CharSequence truncated, Function1 function1) {
+        Intrinsics.checkNotNullParameter(objArr, "<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 : objArr) {
+            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 final Appendable joinTo(byte[] bArr, Appendable buffer, CharSequence separator, CharSequence prefix, CharSequence postfix, int i, CharSequence truncated, Function1 function1) {
+        Intrinsics.checkNotNullParameter(bArr, "<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 (byte b : bArr) {
+            i2++;
+            if (i2 > 1) {
+                buffer.append(separator);
+            }
+            if (i >= 0 && i2 > i) {
+                break;
+            }
+            if (function1 != null) {
+                buffer.append((CharSequence) function1.invoke(Byte.valueOf(b)));
+            } else {
+                buffer.append(String.valueOf((int) b));
+            }
+        }
+        if (i >= 0 && i2 > i) {
+            buffer.append(truncated);
+        }
+        buffer.append(postfix);
+        return buffer;
+    }
+
+    public static /* synthetic */ String joinToString$default(Object[] objArr, 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(objArr, charSequence, charSequence5, charSequence6, i3, charSequence7, function1);
+    }
+
+    public static final String joinToString(Object[] objArr, CharSequence separator, CharSequence prefix, CharSequence postfix, int i, CharSequence truncated, Function1 function1) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        Intrinsics.checkNotNullParameter(separator, "separator");
+        Intrinsics.checkNotNullParameter(prefix, "prefix");
+        Intrinsics.checkNotNullParameter(postfix, "postfix");
+        Intrinsics.checkNotNullParameter(truncated, "truncated");
+        String sb = ((StringBuilder) joinTo(objArr, new StringBuilder(), separator, prefix, postfix, i, truncated, function1)).toString();
+        Intrinsics.checkNotNullExpressionValue(sb, "toString(...)");
+        return sb;
+    }
+
+    public static /* synthetic */ String joinToString$default(byte[] bArr, 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(bArr, charSequence, charSequence5, charSequence6, i3, charSequence7, function1);
+    }
+
+    public static final String joinToString(byte[] bArr, CharSequence separator, CharSequence prefix, CharSequence postfix, int i, CharSequence truncated, Function1 function1) {
+        Intrinsics.checkNotNullParameter(bArr, "<this>");
+        Intrinsics.checkNotNullParameter(separator, "separator");
+        Intrinsics.checkNotNullParameter(prefix, "prefix");
+        Intrinsics.checkNotNullParameter(postfix, "postfix");
+        Intrinsics.checkNotNullParameter(truncated, "truncated");
+        String sb = ((StringBuilder) joinTo(bArr, new StringBuilder(), separator, prefix, postfix, i, truncated, function1)).toString();
+        Intrinsics.checkNotNullExpressionValue(sb, "toString(...)");
+        return sb;
+    }
+}

decompiled/sources/kotlin/collections/ArraysUtilJVM.java

@@ -0,0 +1,11 @@
+package kotlin.collections;
+
+import java.util.Arrays;
+import java.util.List;
+
+/* loaded from: classes5.dex */
+public abstract class ArraysUtilJVM {
+    public static List asList(Object[] objArr) {
+        return Arrays.asList(objArr);
+    }
+}

decompiled/sources/kotlin/collections/BooleanIterator.java

@@ -0,0 +1,24 @@
+package kotlin.collections;
+
+import java.util.Iterator;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public abstract class BooleanIterator implements Iterator, KMappedMarker {
+    public abstract boolean nextBoolean();
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Iterator
+    public /* bridge */ /* synthetic */ Object next() {
+        return Boolean.valueOf(nextBoolean());
+    }
+
+    @Override // java.util.Iterator
+    public final Boolean next() {
+        return Boolean.valueOf(nextBoolean());
+    }
+}

decompiled/sources/kotlin/collections/ByteIterator.java

@@ -0,0 +1,24 @@
+package kotlin.collections;
+
+import java.util.Iterator;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public abstract class ByteIterator implements Iterator, KMappedMarker {
+    public abstract byte nextByte();
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Iterator
+    public /* bridge */ /* synthetic */ Object next() {
+        return Byte.valueOf(nextByte());
+    }
+
+    @Override // java.util.Iterator
+    public final Byte next() {
+        return Byte.valueOf(nextByte());
+    }
+}

decompiled/sources/kotlin/collections/CharIterator.java

@@ -0,0 +1,24 @@
+package kotlin.collections;
+
+import java.util.Iterator;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public abstract class CharIterator implements Iterator, KMappedMarker {
+    public abstract char nextChar();
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Iterator
+    public /* bridge */ /* synthetic */ Object next() {
+        return Character.valueOf(nextChar());
+    }
+
+    @Override // java.util.Iterator
+    public final Character next() {
+        return Character.valueOf(nextChar());
+    }
+}

decompiled/sources/kotlin/collections/CollectionsKt.java

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

decompiled/sources/kotlin/collections/CollectionsKt__CollectionsJVMKt.java

@@ -0,0 +1,47 @@
+package kotlin.collections;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import kotlin.collections.builders.ListBuilder;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class CollectionsKt__CollectionsJVMKt {
+    public static List listOf(Object obj) {
+        List singletonList = Collections.singletonList(obj);
+        Intrinsics.checkNotNullExpressionValue(singletonList, "singletonList(...)");
+        return singletonList;
+    }
+
+    public static List createListBuilder() {
+        return new ListBuilder();
+    }
+
+    public static List createListBuilder(int i) {
+        return new ListBuilder(i);
+    }
+
+    public static List build(List builder) {
+        Intrinsics.checkNotNullParameter(builder, "builder");
+        return ((ListBuilder) builder).build();
+    }
+
+    public static Object[] terminateCollectionToArray(int i, Object[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        if (i < array.length) {
+            array[i] = null;
+        }
+        return array;
+    }
+
+    public static final Object[] copyToArrayOfAny(Object[] objArr, boolean z) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        if (z && Intrinsics.areEqual(objArr.getClass(), Object[].class)) {
+            return objArr;
+        }
+        Object[] copyOf = Arrays.copyOf(objArr, objArr.length, Object[].class);
+        Intrinsics.checkNotNullExpressionValue(copyOf, "copyOf(...)");
+        return copyOf;
+    }
+}

decompiled/sources/kotlin/collections/CollectionsKt__CollectionsKt.java

@@ -0,0 +1,67 @@
+package kotlin.collections;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class CollectionsKt__CollectionsKt extends CollectionsKt__CollectionsJVMKt {
+    public static final Collection asCollection(Object[] objArr) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        return new ArrayAsCollection(objArr, false);
+    }
+
+    public static List emptyList() {
+        return EmptyList.INSTANCE;
+    }
+
+    public static List listOf(Object... elements) {
+        List asList;
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        if (elements.length <= 0) {
+            return emptyList();
+        }
+        asList = ArraysKt___ArraysJvmKt.asList(elements);
+        return asList;
+    }
+
+    public static List mutableListOf(Object... elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        return elements.length == 0 ? new ArrayList() : new ArrayList(new ArrayAsCollection(elements, true));
+    }
+
+    public static ArrayList arrayListOf(Object... elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        return elements.length == 0 ? new ArrayList() : new ArrayList(new ArrayAsCollection(elements, true));
+    }
+
+    public static List listOfNotNull(Object... elements) {
+        List filterNotNull;
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        filterNotNull = ArraysKt___ArraysKt.filterNotNull(elements);
+        return filterNotNull;
+    }
+
+    public static int getLastIndex(List list) {
+        Intrinsics.checkNotNullParameter(list, "<this>");
+        return list.size() - 1;
+    }
+
+    public static final List optimizeReadOnlyList(List list) {
+        Intrinsics.checkNotNullParameter(list, "<this>");
+        int size = list.size();
+        if (size != 0) {
+            return size != 1 ? list : CollectionsKt__CollectionsJVMKt.listOf(list.get(0));
+        }
+        return emptyList();
+    }
+
+    public static void throwIndexOverflow() {
+        throw new ArithmeticException("Index overflow has happened.");
+    }
+
+    public static void throwCountOverflow() {
+        throw new ArithmeticException("Count overflow has happened.");
+    }
+}

decompiled/sources/kotlin/collections/CollectionsKt__IterablesKt.java

@@ -0,0 +1,33 @@
+package kotlin.collections;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class CollectionsKt__IterablesKt extends CollectionsKt__CollectionsKt {
+    public static final Integer collectionSizeOrNull(Iterable iterable) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        if (iterable instanceof Collection) {
+            return Integer.valueOf(((Collection) iterable).size());
+        }
+        return null;
+    }
+
+    public static int collectionSizeOrDefault(Iterable iterable, int i) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        return iterable instanceof Collection ? ((Collection) iterable).size() : i;
+    }
+
+    public static List flatten(Iterable iterable) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        ArrayList arrayList = new ArrayList();
+        Iterator it = iterable.iterator();
+        while (it.hasNext()) {
+            CollectionsKt__MutableCollectionsKt.addAll(arrayList, (Iterable) it.next());
+        }
+        return arrayList;
+    }
+}

decompiled/sources/kotlin/collections/CollectionsKt__IteratorsJVMKt.java

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

decompiled/sources/kotlin/collections/CollectionsKt__IteratorsKt.java

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

decompiled/sources/kotlin/collections/CollectionsKt__MutableCollectionsJVMKt.java

@@ -0,0 +1,24 @@
+package kotlin.collections;
+
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class CollectionsKt__MutableCollectionsJVMKt extends CollectionsKt__IteratorsKt {
+    public static void sort(List list) {
+        Intrinsics.checkNotNullParameter(list, "<this>");
+        if (list.size() > 1) {
+            Collections.sort(list);
+        }
+    }
+
+    public static void sortWith(List list, Comparator comparator) {
+        Intrinsics.checkNotNullParameter(list, "<this>");
+        Intrinsics.checkNotNullParameter(comparator, "comparator");
+        if (list.size() > 1) {
+            Collections.sort(list, comparator);
+        }
+    }
+}

decompiled/sources/kotlin/collections/CollectionsKt__MutableCollectionsKt.java

@@ -0,0 +1,83 @@
+package kotlin.collections;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class CollectionsKt__MutableCollectionsKt extends CollectionsKt__MutableCollectionsJVMKt {
+    public static boolean addAll(Collection collection, Iterable elements) {
+        Intrinsics.checkNotNullParameter(collection, "<this>");
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        if (elements instanceof Collection) {
+            return collection.addAll((Collection) elements);
+        }
+        Iterator it = elements.iterator();
+        boolean z = false;
+        while (it.hasNext()) {
+            if (collection.add(it.next())) {
+                z = true;
+            }
+        }
+        return z;
+    }
+
+    public static boolean addAll(Collection collection, Object[] elements) {
+        List asList;
+        Intrinsics.checkNotNullParameter(collection, "<this>");
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        asList = ArraysKt___ArraysJvmKt.asList(elements);
+        return collection.addAll(asList);
+    }
+
+    public static final Collection convertToListIfNotCollection(Iterable iterable) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        if (!(iterable instanceof Collection)) {
+            iterable = CollectionsKt___CollectionsKt.toList(iterable);
+        }
+        return (Collection) iterable;
+    }
+
+    public static final boolean retainAll(Collection collection, Iterable elements) {
+        Intrinsics.checkNotNullParameter(collection, "<this>");
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        return collection.retainAll(convertToListIfNotCollection(elements));
+    }
+
+    public static boolean removeAll(Iterable iterable, Function1 predicate) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        Intrinsics.checkNotNullParameter(predicate, "predicate");
+        return filterInPlace$CollectionsKt__MutableCollectionsKt(iterable, predicate, true);
+    }
+
+    public static final boolean filterInPlace$CollectionsKt__MutableCollectionsKt(Iterable iterable, Function1 function1, boolean z) {
+        Iterator it = iterable.iterator();
+        boolean z2 = false;
+        while (it.hasNext()) {
+            if (((Boolean) function1.invoke(it.next())).booleanValue() == z) {
+                it.remove();
+                z2 = true;
+            }
+        }
+        return z2;
+    }
+
+    public static Object removeFirstOrNull(List list) {
+        Intrinsics.checkNotNullParameter(list, "<this>");
+        if (list.isEmpty()) {
+            return null;
+        }
+        return list.remove(0);
+    }
+
+    public static Object removeLast(List list) {
+        Intrinsics.checkNotNullParameter(list, "<this>");
+        if (list.isEmpty()) {
+            throw new NoSuchElementException("List is empty.");
+        }
+        return list.remove(CollectionsKt__CollectionsKt.getLastIndex(list));
+    }
+}

decompiled/sources/kotlin/collections/CollectionsKt__ReversedViewsKt.java

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

decompiled/sources/kotlin/collections/CollectionsKt___CollectionsJvmKt.java

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

decompiled/sources/kotlin/collections/CollectionsKt___CollectionsKt.java

@@ -0,0 +1,590 @@
+package kotlin.collections;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.NoSuchElementException;
+import java.util.RandomAccess;
+import java.util.Set;
+import kotlin.TuplesKt;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.random.Random;
+import kotlin.ranges.IntRange;
+import kotlin.sequences.Sequence;
+import kotlin.text.StringsKt__AppendableKt;
+
+/* loaded from: classes5.dex */
+public abstract class CollectionsKt___CollectionsKt extends CollectionsKt___CollectionsJvmKt {
+    public static boolean contains(Iterable iterable, Object obj) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        if (iterable instanceof Collection) {
+            return ((Collection) iterable).contains(obj);
+        }
+        return indexOf(iterable, obj) >= 0;
+    }
+
+    public static final Object elementAt(Iterable iterable, final int i) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        if (iterable instanceof List) {
+            return ((List) iterable).get(i);
+        }
+        return elementAtOrElse(iterable, i, new Function1() { // from class: kotlin.collections.CollectionsKt___CollectionsKt$elementAt$1
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(1);
+            }
+
+            public final Object invoke(int i2) {
+                throw new IndexOutOfBoundsException("Collection doesn't contain element at index " + i + '.');
+            }
+
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Object invoke(Object obj) {
+                return invoke(((Number) obj).intValue());
+            }
+        });
+    }
+
+    public static final Object elementAtOrElse(Iterable iterable, int i, Function1 defaultValue) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        Intrinsics.checkNotNullParameter(defaultValue, "defaultValue");
+        if (iterable instanceof List) {
+            List list = (List) iterable;
+            return (i < 0 || i > CollectionsKt__CollectionsKt.getLastIndex(list)) ? defaultValue.invoke(Integer.valueOf(i)) : list.get(i);
+        }
+        if (i < 0) {
+            return defaultValue.invoke(Integer.valueOf(i));
+        }
+        int i2 = 0;
+        for (Object obj : iterable) {
+            int i3 = i2 + 1;
+            if (i == i2) {
+                return obj;
+            }
+            i2 = i3;
+        }
+        return defaultValue.invoke(Integer.valueOf(i));
+    }
+
+    public static final Object first(Iterable iterable) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        if (iterable instanceof List) {
+            return first((List) iterable);
+        }
+        Iterator it = iterable.iterator();
+        if (!it.hasNext()) {
+            throw new NoSuchElementException("Collection is empty.");
+        }
+        return it.next();
+    }
+
+    public static Object first(List list) {
+        Intrinsics.checkNotNullParameter(list, "<this>");
+        if (list.isEmpty()) {
+            throw new NoSuchElementException("List is empty.");
+        }
+        return list.get(0);
+    }
+
+    public static Object firstOrNull(Iterable iterable) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        if (iterable instanceof List) {
+            List list = (List) iterable;
+            if (list.isEmpty()) {
+                return null;
+            }
+            return list.get(0);
+        }
+        Iterator it = iterable.iterator();
+        if (it.hasNext()) {
+            return it.next();
+        }
+        return null;
+    }
+
+    public static Object firstOrNull(List list) {
+        Intrinsics.checkNotNullParameter(list, "<this>");
+        if (list.isEmpty()) {
+            return null;
+        }
+        return list.get(0);
+    }
+
+    public static Object getOrNull(List list, int i) {
+        Intrinsics.checkNotNullParameter(list, "<this>");
+        if (i < 0 || i > CollectionsKt__CollectionsKt.getLastIndex(list)) {
+            return null;
+        }
+        return list.get(i);
+    }
+
+    public static final int indexOf(Iterable iterable, Object obj) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        if (iterable instanceof List) {
+            return ((List) iterable).indexOf(obj);
+        }
+        int i = 0;
+        for (Object obj2 : iterable) {
+            if (i < 0) {
+                CollectionsKt__CollectionsKt.throwIndexOverflow();
+            }
+            if (Intrinsics.areEqual(obj, obj2)) {
+                return i;
+            }
+            i++;
+        }
+        return -1;
+    }
+
+    public static final Object last(Iterable iterable) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        if (iterable instanceof List) {
+            return last((List) iterable);
+        }
+        Iterator it = iterable.iterator();
+        if (!it.hasNext()) {
+            throw new NoSuchElementException("Collection is empty.");
+        }
+        Object next = it.next();
+        while (it.hasNext()) {
+            next = it.next();
+        }
+        return next;
+    }
+
+    public static Object last(List list) {
+        Intrinsics.checkNotNullParameter(list, "<this>");
+        if (list.isEmpty()) {
+            throw new NoSuchElementException("List is empty.");
+        }
+        return list.get(CollectionsKt__CollectionsKt.getLastIndex(list));
+    }
+
+    public static Object random(Collection collection, Random random) {
+        Intrinsics.checkNotNullParameter(collection, "<this>");
+        Intrinsics.checkNotNullParameter(random, "random");
+        if (collection.isEmpty()) {
+            throw new NoSuchElementException("Collection is empty.");
+        }
+        return elementAt(collection, random.nextInt(collection.size()));
+    }
+
+    public static Object single(Iterable iterable) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        if (iterable instanceof List) {
+            return single((List) iterable);
+        }
+        Iterator it = iterable.iterator();
+        if (!it.hasNext()) {
+            throw new NoSuchElementException("Collection is empty.");
+        }
+        Object next = it.next();
+        if (it.hasNext()) {
+            throw new IllegalArgumentException("Collection has more than one element.");
+        }
+        return next;
+    }
+
+    public static final Object single(List list) {
+        Intrinsics.checkNotNullParameter(list, "<this>");
+        int size = list.size();
+        if (size == 0) {
+            throw new NoSuchElementException("List is empty.");
+        }
+        if (size == 1) {
+            return list.get(0);
+        }
+        throw new IllegalArgumentException("List has more than one element.");
+    }
+
+    public static List drop(Iterable iterable, int i) {
+        ArrayList arrayList;
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        if (i < 0) {
+            throw new IllegalArgumentException(("Requested element count " + i + " is less than zero.").toString());
+        }
+        if (i == 0) {
+            return toList(iterable);
+        }
+        if (iterable instanceof Collection) {
+            Collection collection = (Collection) iterable;
+            int size = collection.size() - i;
+            if (size <= 0) {
+                return CollectionsKt__CollectionsKt.emptyList();
+            }
+            if (size == 1) {
+                return CollectionsKt__CollectionsJVMKt.listOf(last(iterable));
+            }
+            arrayList = new ArrayList(size);
+            if (iterable instanceof List) {
+                if (iterable instanceof RandomAccess) {
+                    int size2 = collection.size();
+                    while (i < size2) {
+                        arrayList.add(((List) iterable).get(i));
+                        i++;
+                    }
+                } else {
+                    ListIterator listIterator = ((List) iterable).listIterator(i);
+                    while (listIterator.hasNext()) {
+                        arrayList.add(listIterator.next());
+                    }
+                }
+                return arrayList;
+            }
+        } else {
+            arrayList = new ArrayList();
+        }
+        int i2 = 0;
+        for (Object obj : iterable) {
+            if (i2 >= i) {
+                arrayList.add(obj);
+            } else {
+                i2++;
+            }
+        }
+        return CollectionsKt__CollectionsKt.optimizeReadOnlyList(arrayList);
+    }
+
+    public static List filterNotNull(Iterable iterable) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        return (List) filterNotNullTo(iterable, new ArrayList());
+    }
+
+    public static final Collection filterNotNullTo(Iterable iterable, Collection destination) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        Intrinsics.checkNotNullParameter(destination, "destination");
+        for (Object obj : iterable) {
+            if (obj != null) {
+                destination.add(obj);
+            }
+        }
+        return destination;
+    }
+
+    public static List slice(List list, IntRange indices) {
+        Intrinsics.checkNotNullParameter(list, "<this>");
+        Intrinsics.checkNotNullParameter(indices, "indices");
+        return indices.isEmpty() ? CollectionsKt__CollectionsKt.emptyList() : toList(list.subList(indices.getStart().intValue(), indices.getEndInclusive().intValue() + 1));
+    }
+
+    public static List take(Iterable iterable, int i) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        if (i < 0) {
+            throw new IllegalArgumentException(("Requested element count " + i + " is less than zero.").toString());
+        }
+        if (i == 0) {
+            return CollectionsKt__CollectionsKt.emptyList();
+        }
+        if (iterable instanceof Collection) {
+            if (i >= ((Collection) iterable).size()) {
+                return toList(iterable);
+            }
+            if (i == 1) {
+                return CollectionsKt__CollectionsJVMKt.listOf(first(iterable));
+            }
+        }
+        ArrayList arrayList = new ArrayList(i);
+        Iterator it = iterable.iterator();
+        int i2 = 0;
+        while (it.hasNext()) {
+            arrayList.add(it.next());
+            i2++;
+            if (i2 == i) {
+                break;
+            }
+        }
+        return CollectionsKt__CollectionsKt.optimizeReadOnlyList(arrayList);
+    }
+
+    public static List sorted(Iterable iterable) {
+        List asList;
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        if (iterable instanceof Collection) {
+            Collection collection = (Collection) iterable;
+            if (collection.size() <= 1) {
+                return toList(iterable);
+            }
+            Object[] array = collection.toArray(new Comparable[0]);
+            ArraysKt___ArraysJvmKt.sort((Comparable[]) array);
+            asList = ArraysKt___ArraysJvmKt.asList(array);
+            return asList;
+        }
+        List mutableList = toMutableList(iterable);
+        CollectionsKt__MutableCollectionsJVMKt.sort(mutableList);
+        return mutableList;
+    }
+
+    public static List sortedWith(Iterable iterable, Comparator comparator) {
+        List asList;
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        Intrinsics.checkNotNullParameter(comparator, "comparator");
+        if (iterable instanceof Collection) {
+            Collection collection = (Collection) iterable;
+            if (collection.size() <= 1) {
+                return toList(iterable);
+            }
+            Object[] array = collection.toArray(new Object[0]);
+            ArraysKt___ArraysJvmKt.sortWith(array, comparator);
+            asList = ArraysKt___ArraysJvmKt.asList(array);
+            return asList;
+        }
+        List mutableList = toMutableList(iterable);
+        CollectionsKt__MutableCollectionsJVMKt.sortWith(mutableList, comparator);
+        return mutableList;
+    }
+
+    public static int[] toIntArray(Collection collection) {
+        Intrinsics.checkNotNullParameter(collection, "<this>");
+        int[] iArr = new int[collection.size()];
+        Iterator it = collection.iterator();
+        int i = 0;
+        while (it.hasNext()) {
+            iArr[i] = ((Number) it.next()).intValue();
+            i++;
+        }
+        return iArr;
+    }
+
+    public static final Collection toCollection(Iterable iterable, Collection destination) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        Intrinsics.checkNotNullParameter(destination, "destination");
+        Iterator it = iterable.iterator();
+        while (it.hasNext()) {
+            destination.add(it.next());
+        }
+        return destination;
+    }
+
+    public static HashSet toHashSet(Iterable iterable) {
+        int mapCapacity;
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        mapCapacity = MapsKt__MapsJVMKt.mapCapacity(CollectionsKt__IterablesKt.collectionSizeOrDefault(iterable, 12));
+        return (HashSet) toCollection(iterable, new HashSet(mapCapacity));
+    }
+
+    public static List toList(Iterable iterable) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        if (iterable instanceof Collection) {
+            Collection collection = (Collection) iterable;
+            int size = collection.size();
+            if (size == 0) {
+                return CollectionsKt__CollectionsKt.emptyList();
+            }
+            if (size != 1) {
+                return toMutableList(collection);
+            }
+            return CollectionsKt__CollectionsJVMKt.listOf(iterable instanceof List ? ((List) iterable).get(0) : iterable.iterator().next());
+        }
+        return CollectionsKt__CollectionsKt.optimizeReadOnlyList(toMutableList(iterable));
+    }
+
+    public static final List toMutableList(Iterable iterable) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        if (iterable instanceof Collection) {
+            return toMutableList((Collection) iterable);
+        }
+        return (List) toCollection(iterable, new ArrayList());
+    }
+
+    public static List toMutableList(Collection collection) {
+        Intrinsics.checkNotNullParameter(collection, "<this>");
+        return new ArrayList(collection);
+    }
+
+    public static Set toSet(Iterable iterable) {
+        Set emptySet;
+        Set of;
+        int mapCapacity;
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        if (iterable instanceof Collection) {
+            Collection collection = (Collection) iterable;
+            int size = collection.size();
+            if (size == 0) {
+                emptySet = SetsKt__SetsKt.emptySet();
+                return emptySet;
+            }
+            if (size == 1) {
+                of = SetsKt__SetsJVMKt.setOf(iterable instanceof List ? ((List) iterable).get(0) : iterable.iterator().next());
+                return of;
+            }
+            mapCapacity = MapsKt__MapsJVMKt.mapCapacity(collection.size());
+            return (Set) toCollection(iterable, new LinkedHashSet(mapCapacity));
+        }
+        return SetsKt__SetsKt.optimizeReadOnlySet((Set) toCollection(iterable, new LinkedHashSet()));
+    }
+
+    public static List distinct(Iterable iterable) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        return toList(toMutableSet(iterable));
+    }
+
+    public static Set intersect(Iterable iterable, Iterable other) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        Intrinsics.checkNotNullParameter(other, "other");
+        Set mutableSet = toMutableSet(iterable);
+        CollectionsKt__MutableCollectionsKt.retainAll(mutableSet, other);
+        return mutableSet;
+    }
+
+    public static Set toMutableSet(Iterable iterable) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        return iterable instanceof Collection ? new LinkedHashSet((Collection) iterable) : (Set) toCollection(iterable, new LinkedHashSet());
+    }
+
+    public static Comparable minOrNull(Iterable iterable) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        Iterator it = iterable.iterator();
+        if (!it.hasNext()) {
+            return null;
+        }
+        Comparable comparable = (Comparable) it.next();
+        while (it.hasNext()) {
+            Comparable comparable2 = (Comparable) it.next();
+            if (comparable.compareTo(comparable2) > 0) {
+                comparable = comparable2;
+            }
+        }
+        return comparable;
+    }
+
+    public static List minus(Iterable iterable, Object obj) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        ArrayList arrayList = new ArrayList(CollectionsKt__IterablesKt.collectionSizeOrDefault(iterable, 10));
+        boolean z = false;
+        for (Object obj2 : iterable) {
+            boolean z2 = true;
+            if (!z && Intrinsics.areEqual(obj2, obj)) {
+                z = true;
+                z2 = false;
+            }
+            if (z2) {
+                arrayList.add(obj2);
+            }
+        }
+        return arrayList;
+    }
+
+    public static List plus(Collection collection, Object obj) {
+        Intrinsics.checkNotNullParameter(collection, "<this>");
+        ArrayList arrayList = new ArrayList(collection.size() + 1);
+        arrayList.addAll(collection);
+        arrayList.add(obj);
+        return arrayList;
+    }
+
+    public static List plus(Iterable iterable, Iterable elements) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        if (iterable instanceof Collection) {
+            return plus((Collection) iterable, elements);
+        }
+        ArrayList arrayList = new ArrayList();
+        CollectionsKt__MutableCollectionsKt.addAll(arrayList, iterable);
+        CollectionsKt__MutableCollectionsKt.addAll(arrayList, elements);
+        return arrayList;
+    }
+
+    public static List plus(Collection collection, Iterable elements) {
+        Intrinsics.checkNotNullParameter(collection, "<this>");
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        if (elements instanceof Collection) {
+            Collection collection2 = (Collection) elements;
+            ArrayList arrayList = new ArrayList(collection.size() + collection2.size());
+            arrayList.addAll(collection);
+            arrayList.addAll(collection2);
+            return arrayList;
+        }
+        ArrayList arrayList2 = new ArrayList(collection);
+        CollectionsKt__MutableCollectionsKt.addAll(arrayList2, elements);
+        return arrayList2;
+    }
+
+    public static List zip(Iterable iterable, Iterable other) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        Intrinsics.checkNotNullParameter(other, "other");
+        Iterator it = iterable.iterator();
+        Iterator it2 = other.iterator();
+        ArrayList arrayList = new ArrayList(Math.min(CollectionsKt__IterablesKt.collectionSizeOrDefault(iterable, 10), CollectionsKt__IterablesKt.collectionSizeOrDefault(other, 10)));
+        while (it.hasNext() && it2.hasNext()) {
+            arrayList.add(TuplesKt.to(it.next(), it2.next()));
+        }
+        return arrayList;
+    }
+
+    public static /* synthetic */ Appendable joinTo$default(Iterable iterable, Appendable appendable, CharSequence charSequence, CharSequence charSequence2, CharSequence charSequence3, int i, CharSequence charSequence4, Function1 function1, int i2, Object obj) {
+        return joinTo(iterable, appendable, (i2 & 2) != 0 ? ", " : charSequence, (i2 & 4) != 0 ? "" : charSequence2, (i2 & 8) == 0 ? charSequence3 : "", (i2 & 16) != 0 ? -1 : i, (i2 & 32) != 0 ? "..." : charSequence4, (i2 & 64) != 0 ? null : function1);
+    }
+
+    public static final Appendable joinTo(Iterable iterable, Appendable buffer, CharSequence separator, CharSequence prefix, CharSequence postfix, int i, CharSequence truncated, Function1 function1) {
+        Intrinsics.checkNotNullParameter(iterable, "<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 : iterable) {
+            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(Iterable iterable, 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(iterable, charSequence, charSequence5, charSequence6, i3, charSequence7, function1);
+    }
+
+    public static final String joinToString(Iterable iterable, CharSequence separator, CharSequence prefix, CharSequence postfix, int i, CharSequence truncated, Function1 function1) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        Intrinsics.checkNotNullParameter(separator, "separator");
+        Intrinsics.checkNotNullParameter(prefix, "prefix");
+        Intrinsics.checkNotNullParameter(postfix, "postfix");
+        Intrinsics.checkNotNullParameter(truncated, "truncated");
+        String sb = ((StringBuilder) joinTo(iterable, new StringBuilder(), separator, prefix, postfix, i, truncated, function1)).toString();
+        Intrinsics.checkNotNullExpressionValue(sb, "toString(...)");
+        return sb;
+    }
+
+    public static Sequence asSequence(final Iterable iterable) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        return new Sequence() { // from class: kotlin.collections.CollectionsKt___CollectionsKt$asSequence$$inlined$Sequence$1
+            @Override // kotlin.sequences.Sequence
+            public Iterator iterator() {
+                return iterable.iterator();
+            }
+        };
+    }
+}

decompiled/sources/kotlin/collections/DoubleIterator.java

@@ -0,0 +1,24 @@
+package kotlin.collections;
+
+import java.util.Iterator;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public abstract class DoubleIterator implements Iterator, KMappedMarker {
+    public abstract double nextDouble();
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Iterator
+    public /* bridge */ /* synthetic */ Object next() {
+        return Double.valueOf(nextDouble());
+    }
+
+    @Override // java.util.Iterator
+    public final Double next() {
+        return Double.valueOf(nextDouble());
+    }
+}

decompiled/sources/kotlin/collections/EmptyIterator.java

@@ -0,0 +1,55 @@
+package kotlin.collections;
+
+import java.util.ListIterator;
+import java.util.NoSuchElementException;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public final class EmptyIterator implements ListIterator, KMappedMarker {
+    public static final EmptyIterator INSTANCE = new EmptyIterator();
+
+    @Override // java.util.ListIterator
+    public /* bridge */ /* synthetic */ void add(Object obj) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.ListIterator, java.util.Iterator
+    public boolean hasNext() {
+        return false;
+    }
+
+    @Override // java.util.ListIterator
+    public boolean hasPrevious() {
+        return false;
+    }
+
+    @Override // java.util.ListIterator
+    public int nextIndex() {
+        return 0;
+    }
+
+    @Override // java.util.ListIterator
+    public int previousIndex() {
+        return -1;
+    }
+
+    @Override // java.util.ListIterator, java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.ListIterator
+    public /* bridge */ /* synthetic */ void set(Object obj) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.ListIterator, java.util.Iterator
+    public Void next() {
+        throw new NoSuchElementException();
+    }
+
+    @Override // java.util.ListIterator
+    public Void previous() {
+        throw new NoSuchElementException();
+    }
+}

decompiled/sources/kotlin/collections/EmptyList.java

@@ -0,0 +1,186 @@
+package kotlin.collections;
+
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.RandomAccess;
+import kotlin.jvm.internal.CollectionToArray;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public final class EmptyList implements List, Serializable, RandomAccess, KMappedMarker {
+    public static final EmptyList INSTANCE = new EmptyList();
+    private static final long serialVersionUID = -7390468764508069838L;
+
+    private final Object readResolve() {
+        return INSTANCE;
+    }
+
+    @Override // java.util.List
+    public /* bridge */ /* synthetic */ void add(int i, Object obj) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.List, java.util.Collection
+    public /* bridge */ /* synthetic */ boolean add(Object obj) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.List
+    public boolean addAll(int i, Collection collection) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.List, java.util.Collection
+    public boolean addAll(Collection collection) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.List, java.util.Collection
+    public void clear() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    public boolean contains(Void element) {
+        Intrinsics.checkNotNullParameter(element, "element");
+        return false;
+    }
+
+    public int getSize() {
+        return 0;
+    }
+
+    @Override // java.util.List, java.util.Collection
+    public int hashCode() {
+        return 1;
+    }
+
+    public int indexOf(Void element) {
+        Intrinsics.checkNotNullParameter(element, "element");
+        return -1;
+    }
+
+    @Override // java.util.List, java.util.Collection
+    public boolean isEmpty() {
+        return true;
+    }
+
+    public int lastIndexOf(Void element) {
+        Intrinsics.checkNotNullParameter(element, "element");
+        return -1;
+    }
+
+    @Override // java.util.List
+    public /* bridge */ /* synthetic */ Object remove(int i) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.List, java.util.Collection
+    public boolean remove(Object obj) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.List, java.util.Collection
+    public boolean removeAll(Collection collection) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.List, java.util.Collection
+    public boolean retainAll(Collection collection) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.List
+    public /* bridge */ /* synthetic */ Object set(int i, Object obj) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.List, java.util.Collection
+    public Object[] toArray() {
+        return CollectionToArray.toArray(this);
+    }
+
+    @Override // java.util.List, java.util.Collection
+    public Object[] toArray(Object[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        return CollectionToArray.toArray(this, array);
+    }
+
+    public String toString() {
+        return "[]";
+    }
+
+    @Override // java.util.List, java.util.Collection
+    public final /* bridge */ boolean contains(Object obj) {
+        if (obj instanceof Void) {
+            return contains((Void) obj);
+        }
+        return false;
+    }
+
+    @Override // java.util.List
+    public final /* bridge */ int indexOf(Object obj) {
+        if (obj instanceof Void) {
+            return indexOf((Void) obj);
+        }
+        return -1;
+    }
+
+    @Override // java.util.List
+    public final /* bridge */ int lastIndexOf(Object obj) {
+        if (obj instanceof Void) {
+            return lastIndexOf((Void) obj);
+        }
+        return -1;
+    }
+
+    @Override // java.util.List, java.util.Collection
+    public final /* bridge */ int size() {
+        return getSize();
+    }
+
+    @Override // java.util.List, java.util.Collection
+    public boolean equals(Object obj) {
+        return (obj instanceof List) && ((List) obj).isEmpty();
+    }
+
+    @Override // java.util.List, java.util.Collection
+    public boolean containsAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        return elements.isEmpty();
+    }
+
+    @Override // java.util.List
+    public Void get(int i) {
+        throw new IndexOutOfBoundsException("Empty list doesn't contain element at index " + i + '.');
+    }
+
+    @Override // java.util.List, java.util.Collection, java.lang.Iterable
+    public Iterator iterator() {
+        return EmptyIterator.INSTANCE;
+    }
+
+    @Override // java.util.List
+    public ListIterator listIterator() {
+        return EmptyIterator.INSTANCE;
+    }
+
+    @Override // java.util.List
+    public ListIterator listIterator(int i) {
+        if (i != 0) {
+            throw new IndexOutOfBoundsException("Index: " + i);
+        }
+        return EmptyIterator.INSTANCE;
+    }
+
+    @Override // java.util.List
+    public List subList(int i, int i2) {
+        if (i == 0 && i2 == 0) {
+            return this;
+        }
+        throw new IndexOutOfBoundsException("fromIndex: " + i + ", toIndex: " + i2);
+    }
+}

decompiled/sources/kotlin/collections/EmptyMap.java

@@ -0,0 +1,117 @@
+package kotlin.collections;
+
+import com.applovin.impl.sdk.utils.JsonUtils;
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public final class EmptyMap implements Map, Serializable, KMappedMarker {
+    public static final EmptyMap INSTANCE = new EmptyMap();
+    private static final long serialVersionUID = 8246714829545688274L;
+
+    private final Object readResolve() {
+        return INSTANCE;
+    }
+
+    @Override // java.util.Map
+    public void clear() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Map
+    public boolean containsKey(Object obj) {
+        return false;
+    }
+
+    public boolean containsValue(Void value) {
+        Intrinsics.checkNotNullParameter(value, "value");
+        return false;
+    }
+
+    @Override // java.util.Map
+    public Void get(Object obj) {
+        return null;
+    }
+
+    public int getSize() {
+        return 0;
+    }
+
+    @Override // java.util.Map
+    public int hashCode() {
+        return 0;
+    }
+
+    @Override // java.util.Map
+    public boolean isEmpty() {
+        return true;
+    }
+
+    @Override // java.util.Map
+    public /* bridge */ /* synthetic */ Object put(Object obj, Object obj2) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Map
+    public void putAll(Map map) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Map
+    public Void remove(Object obj) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    public String toString() {
+        return JsonUtils.EMPTY_JSON;
+    }
+
+    @Override // java.util.Map
+    public final /* bridge */ boolean containsValue(Object obj) {
+        if (obj instanceof Void) {
+            return containsValue((Void) obj);
+        }
+        return false;
+    }
+
+    @Override // java.util.Map
+    public final /* bridge */ Set entrySet() {
+        return getEntries();
+    }
+
+    @Override // java.util.Map
+    public final /* bridge */ Set keySet() {
+        return getKeys();
+    }
+
+    @Override // java.util.Map
+    public final /* bridge */ int size() {
+        return getSize();
+    }
+
+    @Override // java.util.Map
+    public final /* bridge */ Collection values() {
+        return getValues();
+    }
+
+    @Override // java.util.Map
+    public boolean equals(Object obj) {
+        return (obj instanceof Map) && ((Map) obj).isEmpty();
+    }
+
+    public Set getEntries() {
+        return EmptySet.INSTANCE;
+    }
+
+    public Set getKeys() {
+        return EmptySet.INSTANCE;
+    }
+
+    public Collection getValues() {
+        return EmptyList.INSTANCE;
+    }
+}

decompiled/sources/kotlin/collections/EmptySet.java

@@ -0,0 +1,112 @@
+package kotlin.collections;
+
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Set;
+import kotlin.jvm.internal.CollectionToArray;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public final class EmptySet implements Set, Serializable, KMappedMarker {
+    public static final EmptySet INSTANCE = new EmptySet();
+    private static final long serialVersionUID = 3406603774387020532L;
+
+    private final Object readResolve() {
+        return INSTANCE;
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public /* bridge */ /* synthetic */ boolean add(Object obj) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public boolean addAll(Collection collection) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public void clear() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    public boolean contains(Void element) {
+        Intrinsics.checkNotNullParameter(element, "element");
+        return false;
+    }
+
+    public int getSize() {
+        return 0;
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public int hashCode() {
+        return 0;
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public boolean isEmpty() {
+        return true;
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public boolean remove(Object obj) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public boolean removeAll(Collection collection) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public boolean retainAll(Collection collection) {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public Object[] toArray() {
+        return CollectionToArray.toArray(this);
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public Object[] toArray(Object[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        return CollectionToArray.toArray(this, array);
+    }
+
+    public String toString() {
+        return "[]";
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public final /* bridge */ boolean contains(Object obj) {
+        if (obj instanceof Void) {
+            return contains((Void) obj);
+        }
+        return false;
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public final /* bridge */ int size() {
+        return getSize();
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public boolean equals(Object obj) {
+        return (obj instanceof Set) && ((Set) obj).isEmpty();
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public boolean containsAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        return elements.isEmpty();
+    }
+
+    @Override // java.util.Set, java.util.Collection, java.lang.Iterable
+    public Iterator iterator() {
+        return EmptyIterator.INSTANCE;
+    }
+}

decompiled/sources/kotlin/collections/FloatIterator.java

@@ -0,0 +1,24 @@
+package kotlin.collections;
+
+import java.util.Iterator;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public abstract class FloatIterator implements Iterator, KMappedMarker {
+    public abstract float nextFloat();
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Iterator
+    public /* bridge */ /* synthetic */ Object next() {
+        return Float.valueOf(nextFloat());
+    }
+
+    @Override // java.util.Iterator
+    public final Float next() {
+        return Float.valueOf(nextFloat());
+    }
+}

decompiled/sources/kotlin/collections/IndexedValue.java

@@ -0,0 +1,43 @@
+package kotlin.collections;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class IndexedValue {
+    public final int index;
+    public final Object value;
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof IndexedValue)) {
+            return false;
+        }
+        IndexedValue indexedValue = (IndexedValue) obj;
+        return this.index == indexedValue.index && Intrinsics.areEqual(this.value, indexedValue.value);
+    }
+
+    public final int getIndex() {
+        return this.index;
+    }
+
+    public final Object getValue() {
+        return this.value;
+    }
+
+    public int hashCode() {
+        int hashCode = Integer.hashCode(this.index) * 31;
+        Object obj = this.value;
+        return hashCode + (obj == null ? 0 : obj.hashCode());
+    }
+
+    public String toString() {
+        return "IndexedValue(index=" + this.index + ", value=" + this.value + ')';
+    }
+
+    public IndexedValue(int i, Object obj) {
+        this.index = i;
+        this.value = obj;
+    }
+}

decompiled/sources/kotlin/collections/IntIterator.java

@@ -0,0 +1,24 @@
+package kotlin.collections;
+
+import java.util.Iterator;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public abstract class IntIterator implements Iterator, KMappedMarker {
+    public abstract int nextInt();
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Iterator
+    public /* bridge */ /* synthetic */ Object next() {
+        return Integer.valueOf(nextInt());
+    }
+
+    @Override // java.util.Iterator
+    public final Integer next() {
+        return Integer.valueOf(nextInt());
+    }
+}

decompiled/sources/kotlin/collections/LongIterator.java

@@ -0,0 +1,24 @@
+package kotlin.collections;
+
+import java.util.Iterator;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public abstract class LongIterator implements Iterator, KMappedMarker {
+    public abstract long nextLong();
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Iterator
+    public /* bridge */ /* synthetic */ Object next() {
+        return Long.valueOf(nextLong());
+    }
+
+    @Override // java.util.Iterator
+    public final Long next() {
+        return Long.valueOf(nextLong());
+    }
+}

decompiled/sources/kotlin/collections/MapWithDefault.java

@@ -0,0 +1,9 @@
+package kotlin.collections;
+
+import java.util.Map;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public interface MapWithDefault extends Map, KMappedMarker {
+    Object getOrImplicitDefault(Object obj);
+}

decompiled/sources/kotlin/collections/MapsKt.java

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

decompiled/sources/kotlin/collections/MapsKt__MapWithDefaultKt.java

@@ -0,0 +1,20 @@
+package kotlin.collections;
+
+import java.util.Map;
+import java.util.NoSuchElementException;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class MapsKt__MapWithDefaultKt {
+    public static final Object getOrImplicitDefaultNullable(Map map, Object obj) {
+        Intrinsics.checkNotNullParameter(map, "<this>");
+        if (map instanceof MapWithDefault) {
+            return ((MapWithDefault) map).getOrImplicitDefault(obj);
+        }
+        Object obj2 = map.get(obj);
+        if (obj2 != null || map.containsKey(obj)) {
+            return obj2;
+        }
+        throw new NoSuchElementException("Key " + obj + " is missing in the map.");
+    }
+}

decompiled/sources/kotlin/collections/MapsKt__MapsJVMKt.java

@@ -0,0 +1,51 @@
+package kotlin.collections;
+
+import java.util.Collections;
+import java.util.Map;
+import kotlin.Pair;
+import kotlin.collections.builders.MapBuilder;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class MapsKt__MapsJVMKt extends MapsKt__MapWithDefaultKt {
+    public static int mapCapacity(int i) {
+        if (i < 0) {
+            return i;
+        }
+        if (i < 3) {
+            return i + 1;
+        }
+        if (i < 1073741824) {
+            return (int) ((i / 0.75f) + 1.0f);
+        }
+        return Integer.MAX_VALUE;
+    }
+
+    public static Map mapOf(Pair pair) {
+        Intrinsics.checkNotNullParameter(pair, "pair");
+        Map singletonMap = Collections.singletonMap(pair.getFirst(), pair.getSecond());
+        Intrinsics.checkNotNullExpressionValue(singletonMap, "singletonMap(...)");
+        return singletonMap;
+    }
+
+    public static Map createMapBuilder() {
+        return new MapBuilder();
+    }
+
+    public static Map createMapBuilder(int i) {
+        return new MapBuilder(i);
+    }
+
+    public static Map build(Map builder) {
+        Intrinsics.checkNotNullParameter(builder, "builder");
+        return ((MapBuilder) builder).build();
+    }
+
+    public static final Map toSingletonMap(Map map) {
+        Intrinsics.checkNotNullParameter(map, "<this>");
+        Map.Entry entry = (Map.Entry) map.entrySet().iterator().next();
+        Map singletonMap = Collections.singletonMap(entry.getKey(), entry.getValue());
+        Intrinsics.checkNotNullExpressionValue(singletonMap, "with(...)");
+        return singletonMap;
+    }
+}

decompiled/sources/kotlin/collections/MapsKt__MapsKt.java

@@ -0,0 +1,199 @@
+package kotlin.collections;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import kotlin.Pair;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.sequences.Sequence;
+
+/* loaded from: classes5.dex */
+public abstract class MapsKt__MapsKt extends MapsKt__MapsJVMKt {
+    public static Map emptyMap() {
+        EmptyMap emptyMap = EmptyMap.INSTANCE;
+        Intrinsics.checkNotNull(emptyMap, "null cannot be cast to non-null type kotlin.collections.Map<K of kotlin.collections.MapsKt__MapsKt.emptyMap, V of kotlin.collections.MapsKt__MapsKt.emptyMap>");
+        return emptyMap;
+    }
+
+    public static Map mapOf(Pair... pairs) {
+        Map emptyMap;
+        int mapCapacity;
+        Intrinsics.checkNotNullParameter(pairs, "pairs");
+        if (pairs.length > 0) {
+            mapCapacity = MapsKt__MapsJVMKt.mapCapacity(pairs.length);
+            return toMap(pairs, new LinkedHashMap(mapCapacity));
+        }
+        emptyMap = emptyMap();
+        return emptyMap;
+    }
+
+    public static Map mutableMapOf(Pair... pairs) {
+        int mapCapacity;
+        Intrinsics.checkNotNullParameter(pairs, "pairs");
+        mapCapacity = MapsKt__MapsJVMKt.mapCapacity(pairs.length);
+        LinkedHashMap linkedHashMap = new LinkedHashMap(mapCapacity);
+        putAll(linkedHashMap, pairs);
+        return linkedHashMap;
+    }
+
+    public static HashMap hashMapOf(Pair... pairs) {
+        int mapCapacity;
+        Intrinsics.checkNotNullParameter(pairs, "pairs");
+        mapCapacity = MapsKt__MapsJVMKt.mapCapacity(pairs.length);
+        HashMap hashMap = new HashMap(mapCapacity);
+        putAll(hashMap, pairs);
+        return hashMap;
+    }
+
+    public static LinkedHashMap linkedMapOf(Pair... pairs) {
+        int mapCapacity;
+        Intrinsics.checkNotNullParameter(pairs, "pairs");
+        mapCapacity = MapsKt__MapsJVMKt.mapCapacity(pairs.length);
+        return (LinkedHashMap) toMap(pairs, new LinkedHashMap(mapCapacity));
+    }
+
+    public static Object getValue(Map map, Object obj) {
+        Intrinsics.checkNotNullParameter(map, "<this>");
+        return MapsKt__MapWithDefaultKt.getOrImplicitDefaultNullable(map, obj);
+    }
+
+    public static final void putAll(Map map, Pair[] pairs) {
+        Intrinsics.checkNotNullParameter(map, "<this>");
+        Intrinsics.checkNotNullParameter(pairs, "pairs");
+        for (Pair pair : pairs) {
+            map.put(pair.component1(), pair.component2());
+        }
+    }
+
+    public static final void putAll(Map map, Iterable pairs) {
+        Intrinsics.checkNotNullParameter(map, "<this>");
+        Intrinsics.checkNotNullParameter(pairs, "pairs");
+        Iterator it = pairs.iterator();
+        while (it.hasNext()) {
+            Pair pair = (Pair) it.next();
+            map.put(pair.component1(), pair.component2());
+        }
+    }
+
+    public static final void putAll(Map map, Sequence pairs) {
+        Intrinsics.checkNotNullParameter(map, "<this>");
+        Intrinsics.checkNotNullParameter(pairs, "pairs");
+        Iterator it = pairs.iterator();
+        while (it.hasNext()) {
+            Pair pair = (Pair) it.next();
+            map.put(pair.component1(), pair.component2());
+        }
+    }
+
+    public static Map toMap(Iterable iterable) {
+        Map emptyMap;
+        Map mapOf;
+        int mapCapacity;
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        if (iterable instanceof Collection) {
+            Collection collection = (Collection) iterable;
+            int size = collection.size();
+            if (size == 0) {
+                emptyMap = emptyMap();
+                return emptyMap;
+            }
+            if (size != 1) {
+                mapCapacity = MapsKt__MapsJVMKt.mapCapacity(collection.size());
+                return toMap(iterable, new LinkedHashMap(mapCapacity));
+            }
+            mapOf = MapsKt__MapsJVMKt.mapOf((Pair) (iterable instanceof List ? ((List) iterable).get(0) : iterable.iterator().next()));
+            return mapOf;
+        }
+        return optimizeReadOnlyMap(toMap(iterable, new LinkedHashMap()));
+    }
+
+    public static final Map toMap(Iterable iterable, Map destination) {
+        Intrinsics.checkNotNullParameter(iterable, "<this>");
+        Intrinsics.checkNotNullParameter(destination, "destination");
+        putAll(destination, iterable);
+        return destination;
+    }
+
+    public static final Map toMap(Pair[] pairArr, Map destination) {
+        Intrinsics.checkNotNullParameter(pairArr, "<this>");
+        Intrinsics.checkNotNullParameter(destination, "destination");
+        putAll(destination, pairArr);
+        return destination;
+    }
+
+    public static Map toMap(Sequence sequence) {
+        Intrinsics.checkNotNullParameter(sequence, "<this>");
+        return optimizeReadOnlyMap(toMap(sequence, new LinkedHashMap()));
+    }
+
+    public static final Map toMap(Sequence sequence, Map destination) {
+        Intrinsics.checkNotNullParameter(sequence, "<this>");
+        Intrinsics.checkNotNullParameter(destination, "destination");
+        putAll(destination, sequence);
+        return destination;
+    }
+
+    public static Map toMap(Map map) {
+        Map emptyMap;
+        Map mutableMap;
+        Intrinsics.checkNotNullParameter(map, "<this>");
+        int size = map.size();
+        if (size == 0) {
+            emptyMap = emptyMap();
+            return emptyMap;
+        }
+        if (size == 1) {
+            return MapsKt__MapsJVMKt.toSingletonMap(map);
+        }
+        mutableMap = toMutableMap(map);
+        return mutableMap;
+    }
+
+    public static Map toMutableMap(Map map) {
+        Intrinsics.checkNotNullParameter(map, "<this>");
+        return new LinkedHashMap(map);
+    }
+
+    public static Map plus(Map map, Pair pair) {
+        Map mapOf;
+        Intrinsics.checkNotNullParameter(map, "<this>");
+        Intrinsics.checkNotNullParameter(pair, "pair");
+        if (map.isEmpty()) {
+            mapOf = MapsKt__MapsJVMKt.mapOf(pair);
+            return mapOf;
+        }
+        LinkedHashMap linkedHashMap = new LinkedHashMap(map);
+        linkedHashMap.put(pair.getFirst(), pair.getSecond());
+        return linkedHashMap;
+    }
+
+    public static Map plus(Map map, Map map2) {
+        Intrinsics.checkNotNullParameter(map, "<this>");
+        Intrinsics.checkNotNullParameter(map2, "map");
+        LinkedHashMap linkedHashMap = new LinkedHashMap(map);
+        linkedHashMap.putAll(map2);
+        return linkedHashMap;
+    }
+
+    public static Map minus(Map map, Object obj) {
+        Map mutableMap;
+        Intrinsics.checkNotNullParameter(map, "<this>");
+        mutableMap = toMutableMap(map);
+        mutableMap.remove(obj);
+        return optimizeReadOnlyMap(mutableMap);
+    }
+
+    public static final Map optimizeReadOnlyMap(Map map) {
+        Map emptyMap;
+        Intrinsics.checkNotNullParameter(map, "<this>");
+        int size = map.size();
+        if (size != 0) {
+            return size != 1 ? map : MapsKt__MapsJVMKt.toSingletonMap(map);
+        }
+        emptyMap = emptyMap();
+        return emptyMap;
+    }
+}

decompiled/sources/kotlin/collections/MapsKt___MapsJvmKt.java

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

decompiled/sources/kotlin/collections/MapsKt___MapsKt.java

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

decompiled/sources/kotlin/collections/SetsKt.java

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

decompiled/sources/kotlin/collections/SetsKt__SetsJVMKt.java

@@ -0,0 +1,28 @@
+package kotlin.collections;
+
+import java.util.Collections;
+import java.util.Set;
+import kotlin.collections.builders.SetBuilder;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class SetsKt__SetsJVMKt {
+    public static Set setOf(Object obj) {
+        Set singleton = Collections.singleton(obj);
+        Intrinsics.checkNotNullExpressionValue(singleton, "singleton(...)");
+        return singleton;
+    }
+
+    public static Set createSetBuilder() {
+        return new SetBuilder();
+    }
+
+    public static Set createSetBuilder(int i) {
+        return new SetBuilder(i);
+    }
+
+    public static Set build(Set builder) {
+        Intrinsics.checkNotNullParameter(builder, "builder");
+        return ((SetBuilder) builder).build();
+    }
+}

decompiled/sources/kotlin/collections/SetsKt__SetsKt.java

@@ -0,0 +1,55 @@
+package kotlin.collections;
+
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class SetsKt__SetsKt extends SetsKt__SetsJVMKt {
+    public static Set emptySet() {
+        return EmptySet.INSTANCE;
+    }
+
+    public static Set setOf(Object... elements) {
+        Set emptySet;
+        Set set;
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        if (elements.length > 0) {
+            set = ArraysKt___ArraysKt.toSet(elements);
+            return set;
+        }
+        emptySet = emptySet();
+        return emptySet;
+    }
+
+    public static Set mutableSetOf(Object... elements) {
+        int mapCapacity;
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        mapCapacity = MapsKt__MapsJVMKt.mapCapacity(elements.length);
+        return (Set) ArraysKt___ArraysKt.toCollection(elements, new LinkedHashSet(mapCapacity));
+    }
+
+    public static HashSet hashSetOf(Object... elements) {
+        int mapCapacity;
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        mapCapacity = MapsKt__MapsJVMKt.mapCapacity(elements.length);
+        return (HashSet) ArraysKt___ArraysKt.toCollection(elements, new HashSet(mapCapacity));
+    }
+
+    public static final Set optimizeReadOnlySet(Set set) {
+        Set emptySet;
+        Set of;
+        Intrinsics.checkNotNullParameter(set, "<this>");
+        int size = set.size();
+        if (size == 0) {
+            emptySet = emptySet();
+            return emptySet;
+        }
+        if (size != 1) {
+            return set;
+        }
+        of = SetsKt__SetsJVMKt.setOf(set.iterator().next());
+        return of;
+    }
+}

decompiled/sources/kotlin/collections/SetsKt___SetsKt.java

@@ -0,0 +1,55 @@
+package kotlin.collections;
+
+import java.util.LinkedHashSet;
+import java.util.Set;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class SetsKt___SetsKt extends SetsKt__SetsKt {
+    public static Set minus(Set set, Object obj) {
+        int mapCapacity;
+        Intrinsics.checkNotNullParameter(set, "<this>");
+        mapCapacity = MapsKt__MapsJVMKt.mapCapacity(set.size());
+        LinkedHashSet linkedHashSet = new LinkedHashSet(mapCapacity);
+        boolean z = false;
+        for (Object obj2 : set) {
+            boolean z2 = true;
+            if (!z && Intrinsics.areEqual(obj2, obj)) {
+                z = true;
+                z2 = false;
+            }
+            if (z2) {
+                linkedHashSet.add(obj2);
+            }
+        }
+        return linkedHashSet;
+    }
+
+    public static Set plus(Set set, Object obj) {
+        int mapCapacity;
+        Intrinsics.checkNotNullParameter(set, "<this>");
+        mapCapacity = MapsKt__MapsJVMKt.mapCapacity(set.size() + 1);
+        LinkedHashSet linkedHashSet = new LinkedHashSet(mapCapacity);
+        linkedHashSet.addAll(set);
+        linkedHashSet.add(obj);
+        return linkedHashSet;
+    }
+
+    public static Set plus(Set set, Iterable elements) {
+        int size;
+        int mapCapacity;
+        Intrinsics.checkNotNullParameter(set, "<this>");
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        Integer collectionSizeOrNull = CollectionsKt__IterablesKt.collectionSizeOrNull(elements);
+        if (collectionSizeOrNull != null) {
+            size = set.size() + collectionSizeOrNull.intValue();
+        } else {
+            size = set.size() * 2;
+        }
+        mapCapacity = MapsKt__MapsJVMKt.mapCapacity(size);
+        LinkedHashSet linkedHashSet = new LinkedHashSet(mapCapacity);
+        linkedHashSet.addAll(set);
+        CollectionsKt__MutableCollectionsKt.addAll(linkedHashSet, elements);
+        return linkedHashSet;
+    }
+}

decompiled/sources/kotlin/collections/ShortIterator.java

@@ -0,0 +1,24 @@
+package kotlin.collections;
+
+import java.util.Iterator;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public abstract class ShortIterator implements Iterator, KMappedMarker {
+    public abstract short nextShort();
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Iterator
+    public /* bridge */ /* synthetic */ Object next() {
+        return Short.valueOf(nextShort());
+    }
+
+    @Override // java.util.Iterator
+    public final Short next() {
+        return Short.valueOf(nextShort());
+    }
+}

decompiled/sources/kotlin/collections/State.java

@@ -0,0 +1,42 @@
+package kotlin.collections;
+
+import com.facebook.internal.AnalyticsEvents;
+import kotlin.enums.EnumEntries;
+import kotlin.enums.EnumEntriesKt;
+
+/* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
+/* JADX WARN: Unknown enum class pattern. Please report as an issue! */
+/* loaded from: classes5.dex */
+public final class State {
+    private static final /* synthetic */ EnumEntries $ENTRIES;
+    private static final /* synthetic */ State[] $VALUES;
+    public static final State Ready = new State("Ready", 0);
+    public static final State NotReady = new State("NotReady", 1);
+    public static final State Done = new State("Done", 2);
+    public static final State Failed = new State(AnalyticsEvents.PARAMETER_DIALOG_OUTCOME_VALUE_FAILED, 3);
+
+    private static final /* synthetic */ State[] $values() {
+        return new State[]{Ready, NotReady, Done, Failed};
+    }
+
+    public static EnumEntries getEntries() {
+        return $ENTRIES;
+    }
+
+    public static State valueOf(String str) {
+        return (State) Enum.valueOf(State.class, str);
+    }
+
+    public static State[] values() {
+        return (State[]) $VALUES.clone();
+    }
+
+    private State(String str, int i) {
+    }
+
+    static {
+        State[] $values = $values();
+        $VALUES = $values;
+        $ENTRIES = EnumEntriesKt.enumEntries($values);
+    }
+}

decompiled/sources/kotlin/collections/builders/AbstractMapBuilderEntrySet.java

@@ -0,0 +1,33 @@
+package kotlin.collections.builders;
+
+import java.util.Map;
+import kotlin.collections.AbstractMutableSet;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class AbstractMapBuilderEntrySet extends AbstractMutableSet {
+    public abstract boolean containsEntry(Map.Entry entry);
+
+    public abstract /* bridge */ boolean remove(Map.Entry entry);
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public final /* bridge */ boolean contains(Object obj) {
+        if (obj instanceof Map.Entry) {
+            return contains((Map.Entry) obj);
+        }
+        return false;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public final /* bridge */ boolean remove(Object obj) {
+        if (obj instanceof Map.Entry) {
+            return remove((Map.Entry) obj);
+        }
+        return false;
+    }
+
+    public final boolean contains(Map.Entry element) {
+        Intrinsics.checkNotNullParameter(element, "element");
+        return containsEntry(element);
+    }
+}

decompiled/sources/kotlin/collections/builders/ListBuilder.java

@@ -0,0 +1,540 @@
+package kotlin.collections.builders;
+
+import java.io.NotSerializableException;
+import java.io.Serializable;
+import java.util.AbstractList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.ConcurrentModificationException;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.NoSuchElementException;
+import java.util.RandomAccess;
+import kotlin.collections.AbstractMutableList;
+import kotlin.collections.ArraysKt___ArraysJvmKt;
+import kotlin.collections.CollectionsKt__CollectionsJVMKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.markers.KMutableList;
+import kotlin.jvm.internal.markers.KMutableListIterator;
+
+/* loaded from: classes5.dex */
+public final class ListBuilder extends AbstractMutableList implements List, RandomAccess, Serializable, KMutableList {
+    public static final Companion Companion = new Companion(null);
+    public static final ListBuilder Empty;
+    public Object[] array;
+    public final ListBuilder backing;
+    public boolean isReadOnly;
+    public int length;
+    public int offset;
+    public final ListBuilder root;
+
+    public final void registerModification() {
+        ((AbstractList) this).modCount++;
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+
+    public ListBuilder(Object[] objArr, int i, int i2, boolean z, ListBuilder listBuilder, ListBuilder listBuilder2) {
+        this.array = objArr;
+        this.offset = i;
+        this.length = i2;
+        this.isReadOnly = z;
+        this.backing = listBuilder;
+        this.root = listBuilder2;
+        if (listBuilder != null) {
+            ((AbstractList) this).modCount = ((AbstractList) listBuilder).modCount;
+        }
+    }
+
+    static {
+        ListBuilder listBuilder = new ListBuilder(0);
+        listBuilder.isReadOnly = true;
+        Empty = listBuilder;
+    }
+
+    public ListBuilder() {
+        this(10);
+    }
+
+    public ListBuilder(int i) {
+        this(ListBuilderKt.arrayOfUninitializedElements(i), 0, 0, false, null, null);
+    }
+
+    public final List build() {
+        if (this.backing != null) {
+            throw new IllegalStateException();
+        }
+        checkIsMutable();
+        this.isReadOnly = true;
+        return this.length > 0 ? this : Empty;
+    }
+
+    private final Object writeReplace() {
+        if (isEffectivelyReadOnly()) {
+            return new SerializedCollection(this, 0);
+        }
+        throw new NotSerializableException("The list cannot be serialized while it is being built.");
+    }
+
+    @Override // kotlin.collections.AbstractMutableList
+    public int getSize() {
+        checkForComodification();
+        return this.length;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public boolean isEmpty() {
+        checkForComodification();
+        return this.length == 0;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public Object get(int i) {
+        checkForComodification();
+        kotlin.collections.AbstractList.Companion.checkElementIndex$kotlin_stdlib(i, this.length);
+        return this.array[this.offset + i];
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public Object set(int i, Object obj) {
+        checkIsMutable();
+        checkForComodification();
+        kotlin.collections.AbstractList.Companion.checkElementIndex$kotlin_stdlib(i, this.length);
+        Object[] objArr = this.array;
+        int i2 = this.offset;
+        Object obj2 = objArr[i2 + i];
+        objArr[i2 + i] = obj;
+        return obj2;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public int indexOf(Object obj) {
+        checkForComodification();
+        for (int i = 0; i < this.length; i++) {
+            if (Intrinsics.areEqual(this.array[this.offset + i], obj)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public int lastIndexOf(Object obj) {
+        checkForComodification();
+        for (int i = this.length - 1; i >= 0; i--) {
+            if (Intrinsics.areEqual(this.array[this.offset + i], obj)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.List
+    public Iterator iterator() {
+        return listIterator(0);
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public ListIterator listIterator() {
+        return listIterator(0);
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public ListIterator listIterator(int i) {
+        checkForComodification();
+        kotlin.collections.AbstractList.Companion.checkPositionIndex$kotlin_stdlib(i, this.length);
+        return new Itr(this, i);
+    }
+
+    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public boolean add(Object obj) {
+        checkIsMutable();
+        checkForComodification();
+        addAtInternal(this.offset + this.length, obj);
+        return true;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public void add(int i, Object obj) {
+        checkIsMutable();
+        checkForComodification();
+        kotlin.collections.AbstractList.Companion.checkPositionIndex$kotlin_stdlib(i, this.length);
+        addAtInternal(this.offset + i, obj);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public boolean addAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        checkIsMutable();
+        checkForComodification();
+        int size = elements.size();
+        addAllInternal(this.offset + this.length, elements, size);
+        return size > 0;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public boolean addAll(int i, Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        checkIsMutable();
+        checkForComodification();
+        kotlin.collections.AbstractList.Companion.checkPositionIndex$kotlin_stdlib(i, this.length);
+        int size = elements.size();
+        addAllInternal(this.offset + i, elements, size);
+        return size > 0;
+    }
+
+    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public void clear() {
+        checkIsMutable();
+        checkForComodification();
+        removeRangeInternal(this.offset, this.length);
+    }
+
+    @Override // kotlin.collections.AbstractMutableList
+    public Object removeAt(int i) {
+        checkIsMutable();
+        checkForComodification();
+        kotlin.collections.AbstractList.Companion.checkElementIndex$kotlin_stdlib(i, this.length);
+        return removeAtInternal(this.offset + i);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public boolean remove(Object obj) {
+        checkIsMutable();
+        checkForComodification();
+        int indexOf = indexOf(obj);
+        if (indexOf >= 0) {
+            remove(indexOf);
+        }
+        return indexOf >= 0;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public boolean removeAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        checkIsMutable();
+        checkForComodification();
+        return retainOrRemoveAllInternal(this.offset, this.length, elements, false) > 0;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public boolean retainAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        checkIsMutable();
+        checkForComodification();
+        return retainOrRemoveAllInternal(this.offset, this.length, elements, true) > 0;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public List subList(int i, int i2) {
+        kotlin.collections.AbstractList.Companion.checkRangeIndexes$kotlin_stdlib(i, i2, this.length);
+        Object[] objArr = this.array;
+        int i3 = this.offset + i;
+        int i4 = i2 - i;
+        boolean z = this.isReadOnly;
+        ListBuilder listBuilder = this.root;
+        return new ListBuilder(objArr, i3, i4, z, this, listBuilder == null ? this : listBuilder);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public Object[] toArray(Object[] destination) {
+        Object[] terminateCollectionToArray;
+        Intrinsics.checkNotNullParameter(destination, "destination");
+        checkForComodification();
+        int length = destination.length;
+        int i = this.length;
+        if (length < i) {
+            Object[] objArr = this.array;
+            int i2 = this.offset;
+            Object[] copyOfRange = Arrays.copyOfRange(objArr, i2, i + i2, destination.getClass());
+            Intrinsics.checkNotNullExpressionValue(copyOfRange, "copyOfRange(...)");
+            return copyOfRange;
+        }
+        Object[] objArr2 = this.array;
+        int i3 = this.offset;
+        ArraysKt___ArraysJvmKt.copyInto(objArr2, destination, 0, i3, i + i3);
+        terminateCollectionToArray = CollectionsKt__CollectionsJVMKt.terminateCollectionToArray(this.length, destination);
+        return terminateCollectionToArray;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public Object[] toArray() {
+        Object[] copyOfRange;
+        checkForComodification();
+        Object[] objArr = this.array;
+        int i = this.offset;
+        copyOfRange = ArraysKt___ArraysJvmKt.copyOfRange(objArr, i, this.length + i);
+        return copyOfRange;
+    }
+
+    @Override // java.util.AbstractList, java.util.Collection, java.util.List
+    public boolean equals(Object obj) {
+        checkForComodification();
+        return obj == this || ((obj instanceof List) && contentEquals((List) obj));
+    }
+
+    @Override // java.util.AbstractList, java.util.Collection, java.util.List
+    public int hashCode() {
+        int subarrayContentHashCode;
+        checkForComodification();
+        subarrayContentHashCode = ListBuilderKt.subarrayContentHashCode(this.array, this.offset, this.length);
+        return subarrayContentHashCode;
+    }
+
+    @Override // java.util.AbstractCollection
+    public String toString() {
+        String subarrayContentToString;
+        checkForComodification();
+        subarrayContentToString = ListBuilderKt.subarrayContentToString(this.array, this.offset, this.length, this);
+        return subarrayContentToString;
+    }
+
+    public final void checkForComodification() {
+        ListBuilder listBuilder = this.root;
+        if (listBuilder != null && ((AbstractList) listBuilder).modCount != ((AbstractList) this).modCount) {
+            throw new ConcurrentModificationException();
+        }
+    }
+
+    public final void checkIsMutable() {
+        if (isEffectivelyReadOnly()) {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    public final boolean isEffectivelyReadOnly() {
+        ListBuilder listBuilder;
+        return this.isReadOnly || ((listBuilder = this.root) != null && listBuilder.isReadOnly);
+    }
+
+    public final void ensureExtraCapacity(int i) {
+        ensureCapacityInternal(this.length + i);
+    }
+
+    public final void ensureCapacityInternal(int i) {
+        if (i < 0) {
+            throw new OutOfMemoryError();
+        }
+        Object[] objArr = this.array;
+        if (i > objArr.length) {
+            this.array = ListBuilderKt.copyOfUninitializedElements(this.array, kotlin.collections.AbstractList.Companion.newCapacity$kotlin_stdlib(objArr.length, i));
+        }
+    }
+
+    public final boolean contentEquals(List list) {
+        boolean subarrayContentEquals;
+        subarrayContentEquals = ListBuilderKt.subarrayContentEquals(this.array, this.offset, this.length, list);
+        return subarrayContentEquals;
+    }
+
+    public final void insertAtInternal(int i, int i2) {
+        ensureExtraCapacity(i2);
+        Object[] objArr = this.array;
+        ArraysKt___ArraysJvmKt.copyInto(objArr, objArr, i + i2, i, this.offset + this.length);
+        this.length += i2;
+    }
+
+    public final void addAtInternal(int i, Object obj) {
+        registerModification();
+        ListBuilder listBuilder = this.backing;
+        if (listBuilder != null) {
+            listBuilder.addAtInternal(i, obj);
+            this.array = this.backing.array;
+            this.length++;
+        } else {
+            insertAtInternal(i, 1);
+            this.array[i] = obj;
+        }
+    }
+
+    public final void addAllInternal(int i, Collection collection, int i2) {
+        registerModification();
+        ListBuilder listBuilder = this.backing;
+        if (listBuilder != null) {
+            listBuilder.addAllInternal(i, collection, i2);
+            this.array = this.backing.array;
+            this.length += i2;
+        } else {
+            insertAtInternal(i, i2);
+            Iterator it = collection.iterator();
+            for (int i3 = 0; i3 < i2; i3++) {
+                this.array[i + i3] = it.next();
+            }
+        }
+    }
+
+    public final Object removeAtInternal(int i) {
+        registerModification();
+        ListBuilder listBuilder = this.backing;
+        if (listBuilder != null) {
+            this.length--;
+            return listBuilder.removeAtInternal(i);
+        }
+        Object[] objArr = this.array;
+        Object obj = objArr[i];
+        ArraysKt___ArraysJvmKt.copyInto(objArr, objArr, i, i + 1, this.offset + this.length);
+        ListBuilderKt.resetAt(this.array, (this.offset + this.length) - 1);
+        this.length--;
+        return obj;
+    }
+
+    public final void removeRangeInternal(int i, int i2) {
+        if (i2 > 0) {
+            registerModification();
+        }
+        ListBuilder listBuilder = this.backing;
+        if (listBuilder != null) {
+            listBuilder.removeRangeInternal(i, i2);
+        } else {
+            Object[] objArr = this.array;
+            ArraysKt___ArraysJvmKt.copyInto(objArr, objArr, i, i + i2, this.length);
+            Object[] objArr2 = this.array;
+            int i3 = this.length;
+            ListBuilderKt.resetRange(objArr2, i3 - i2, i3);
+        }
+        this.length -= i2;
+    }
+
+    public final int retainOrRemoveAllInternal(int i, int i2, Collection collection, boolean z) {
+        int i3;
+        ListBuilder listBuilder = this.backing;
+        if (listBuilder != null) {
+            i3 = listBuilder.retainOrRemoveAllInternal(i, i2, collection, z);
+        } else {
+            int i4 = 0;
+            int i5 = 0;
+            while (i4 < i2) {
+                int i6 = i + i4;
+                if (collection.contains(this.array[i6]) == z) {
+                    Object[] objArr = this.array;
+                    i4++;
+                    objArr[i5 + i] = objArr[i6];
+                    i5++;
+                } else {
+                    i4++;
+                }
+            }
+            int i7 = i2 - i5;
+            Object[] objArr2 = this.array;
+            ArraysKt___ArraysJvmKt.copyInto(objArr2, objArr2, i + i5, i2 + i, this.length);
+            Object[] objArr3 = this.array;
+            int i8 = this.length;
+            ListBuilderKt.resetRange(objArr3, i8 - i7, i8);
+            i3 = i7;
+        }
+        if (i3 > 0) {
+            registerModification();
+        }
+        this.length -= i3;
+        return i3;
+    }
+
+    public static final class Itr implements ListIterator, KMutableListIterator {
+        public int expectedModCount;
+        public int index;
+        public int lastIndex;
+        public final ListBuilder list;
+
+        @Override // java.util.ListIterator
+        public boolean hasPrevious() {
+            return this.index > 0;
+        }
+
+        @Override // java.util.ListIterator
+        public int nextIndex() {
+            return this.index;
+        }
+
+        @Override // java.util.ListIterator
+        public int previousIndex() {
+            return this.index - 1;
+        }
+
+        public Itr(ListBuilder list, int i) {
+            Intrinsics.checkNotNullParameter(list, "list");
+            this.list = list;
+            this.index = i;
+            this.lastIndex = -1;
+            this.expectedModCount = ((AbstractList) list).modCount;
+        }
+
+        @Override // java.util.ListIterator, java.util.Iterator
+        public boolean hasNext() {
+            return this.index < this.list.length;
+        }
+
+        @Override // java.util.ListIterator
+        public Object previous() {
+            checkForComodification();
+            int i = this.index;
+            if (i > 0) {
+                int i2 = i - 1;
+                this.index = i2;
+                this.lastIndex = i2;
+                return this.list.array[this.list.offset + this.lastIndex];
+            }
+            throw new NoSuchElementException();
+        }
+
+        @Override // java.util.ListIterator, java.util.Iterator
+        public Object next() {
+            checkForComodification();
+            if (this.index < this.list.length) {
+                int i = this.index;
+                this.index = i + 1;
+                this.lastIndex = i;
+                return this.list.array[this.list.offset + this.lastIndex];
+            }
+            throw new NoSuchElementException();
+        }
+
+        @Override // java.util.ListIterator
+        public void set(Object obj) {
+            checkForComodification();
+            int i = this.lastIndex;
+            if (i == -1) {
+                throw new IllegalStateException("Call next() or previous() before replacing element from the iterator.".toString());
+            }
+            this.list.set(i, obj);
+        }
+
+        @Override // java.util.ListIterator
+        public void add(Object obj) {
+            checkForComodification();
+            ListBuilder listBuilder = this.list;
+            int i = this.index;
+            this.index = i + 1;
+            listBuilder.add(i, obj);
+            this.lastIndex = -1;
+            this.expectedModCount = ((AbstractList) this.list).modCount;
+        }
+
+        @Override // java.util.ListIterator, java.util.Iterator
+        public void remove() {
+            checkForComodification();
+            int i = this.lastIndex;
+            if (i == -1) {
+                throw new IllegalStateException("Call next() or previous() before removing element from the iterator.".toString());
+            }
+            this.list.remove(i);
+            this.index = this.lastIndex;
+            this.lastIndex = -1;
+            this.expectedModCount = ((AbstractList) this.list).modCount;
+        }
+
+        private final void checkForComodification() {
+            if (((AbstractList) this.list).modCount != this.expectedModCount) {
+                throw new ConcurrentModificationException();
+            }
+        }
+    }
+}

decompiled/sources/kotlin/collections/builders/ListBuilderKt.java

@@ -0,0 +1,78 @@
+package kotlin.collections.builders;
+
+import com.ironsource.v8;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class ListBuilderKt {
+    public static final Object[] arrayOfUninitializedElements(int i) {
+        if (i < 0) {
+            throw new IllegalArgumentException("capacity must be non-negative.".toString());
+        }
+        return new Object[i];
+    }
+
+    public static final String subarrayContentToString(Object[] objArr, int i, int i2, Collection collection) {
+        StringBuilder sb = new StringBuilder((i2 * 3) + 2);
+        sb.append(v8.i.d);
+        for (int i3 = 0; i3 < i2; i3++) {
+            if (i3 > 0) {
+                sb.append(", ");
+            }
+            Object obj = objArr[i + i3];
+            if (obj == collection) {
+                sb.append("(this Collection)");
+            } else {
+                sb.append(obj);
+            }
+        }
+        sb.append(v8.i.e);
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "toString(...)");
+        return sb2;
+    }
+
+    public static final int subarrayContentHashCode(Object[] objArr, int i, int i2) {
+        int i3 = 1;
+        for (int i4 = 0; i4 < i2; i4++) {
+            Object obj = objArr[i + i4];
+            i3 = (i3 * 31) + (obj != null ? obj.hashCode() : 0);
+        }
+        return i3;
+    }
+
+    public static final boolean subarrayContentEquals(Object[] objArr, int i, int i2, List list) {
+        if (i2 != list.size()) {
+            return false;
+        }
+        for (int i3 = 0; i3 < i2; i3++) {
+            if (!Intrinsics.areEqual(objArr[i + i3], list.get(i3))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static final Object[] copyOfUninitializedElements(Object[] objArr, int i) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        Object[] copyOf = Arrays.copyOf(objArr, i);
+        Intrinsics.checkNotNullExpressionValue(copyOf, "copyOf(...)");
+        return copyOf;
+    }
+
+    public static final void resetAt(Object[] objArr, int i) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        objArr[i] = null;
+    }
+
+    public static final void resetRange(Object[] objArr, int i, int i2) {
+        Intrinsics.checkNotNullParameter(objArr, "<this>");
+        while (i < i2) {
+            resetAt(objArr, i);
+            i++;
+        }
+    }
+}

decompiled/sources/kotlin/collections/builders/MapBuilder.java

@@ -0,0 +1,884 @@
+package kotlin.collections.builders;
+
+import com.ironsource.nb;
+import java.io.NotSerializableException;
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.ConcurrentModificationException;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import kotlin.collections.AbstractList;
+import kotlin.collections.ArraysKt___ArraysJvmKt;
+import kotlin.collections.IntIterator;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.markers.KMutableIterator;
+import kotlin.jvm.internal.markers.KMutableMap;
+import kotlin.ranges.IntRange;
+import kotlin.ranges.RangesKt___RangesKt;
+
+/* loaded from: classes5.dex */
+public final class MapBuilder implements Map, Serializable, KMutableMap {
+    public static final Companion Companion = new Companion(null);
+    public static final MapBuilder Empty;
+    public MapBuilderEntries entriesView;
+    public int[] hashArray;
+    public int hashShift;
+    public boolean isReadOnly;
+    public Object[] keysArray;
+    public MapBuilderKeys keysView;
+    public int length;
+    public int maxProbeDistance;
+    public int modCount;
+    public int[] presenceArray;
+    public int size;
+    public Object[] valuesArray;
+    public MapBuilderValues valuesView;
+
+    private final void registerModification() {
+        this.modCount++;
+    }
+
+    public int getSize() {
+        return this.size;
+    }
+
+    public final boolean isReadOnly$kotlin_stdlib() {
+        return this.isReadOnly;
+    }
+
+    public MapBuilder(Object[] objArr, Object[] objArr2, int[] iArr, int[] iArr2, int i, int i2) {
+        this.keysArray = objArr;
+        this.valuesArray = objArr2;
+        this.presenceArray = iArr;
+        this.hashArray = iArr2;
+        this.maxProbeDistance = i;
+        this.length = i2;
+        this.hashShift = Companion.computeShift(getHashSize());
+    }
+
+    @Override // java.util.Map
+    public final /* bridge */ Set entrySet() {
+        return getEntries();
+    }
+
+    @Override // java.util.Map
+    public final /* bridge */ Set keySet() {
+        return getKeys();
+    }
+
+    @Override // java.util.Map
+    public final /* bridge */ int size() {
+        return getSize();
+    }
+
+    @Override // java.util.Map
+    public final /* bridge */ Collection values() {
+        return getValues();
+    }
+
+    public MapBuilder() {
+        this(8);
+    }
+
+    public MapBuilder(int i) {
+        this(ListBuilderKt.arrayOfUninitializedElements(i), null, new int[i], new int[Companion.computeHashSize(i)], 2, 0);
+    }
+
+    public final Map build() {
+        checkIsMutable$kotlin_stdlib();
+        this.isReadOnly = true;
+        if (size() > 0) {
+            return this;
+        }
+        MapBuilder mapBuilder = Empty;
+        Intrinsics.checkNotNull(mapBuilder, "null cannot be cast to non-null type kotlin.collections.Map<K of kotlin.collections.builders.MapBuilder, V of kotlin.collections.builders.MapBuilder>");
+        return mapBuilder;
+    }
+
+    private final Object writeReplace() {
+        if (this.isReadOnly) {
+            return new SerializedMap(this);
+        }
+        throw new NotSerializableException("The map cannot be serialized while it is being built.");
+    }
+
+    @Override // java.util.Map
+    public boolean isEmpty() {
+        return size() == 0;
+    }
+
+    @Override // java.util.Map
+    public boolean containsKey(Object obj) {
+        return findKey(obj) >= 0;
+    }
+
+    @Override // java.util.Map
+    public boolean containsValue(Object obj) {
+        return findValue(obj) >= 0;
+    }
+
+    @Override // java.util.Map
+    public Object get(Object obj) {
+        int findKey = findKey(obj);
+        if (findKey < 0) {
+            return null;
+        }
+        Object[] objArr = this.valuesArray;
+        Intrinsics.checkNotNull(objArr);
+        return objArr[findKey];
+    }
+
+    @Override // java.util.Map
+    public Object put(Object obj, Object obj2) {
+        checkIsMutable$kotlin_stdlib();
+        int addKey$kotlin_stdlib = addKey$kotlin_stdlib(obj);
+        Object[] allocateValuesArray = allocateValuesArray();
+        if (addKey$kotlin_stdlib < 0) {
+            int i = (-addKey$kotlin_stdlib) - 1;
+            Object obj3 = allocateValuesArray[i];
+            allocateValuesArray[i] = obj2;
+            return obj3;
+        }
+        allocateValuesArray[addKey$kotlin_stdlib] = obj2;
+        return null;
+    }
+
+    @Override // java.util.Map
+    public void putAll(Map from) {
+        Intrinsics.checkNotNullParameter(from, "from");
+        checkIsMutable$kotlin_stdlib();
+        putAllEntries(from.entrySet());
+    }
+
+    @Override // java.util.Map
+    public Object remove(Object obj) {
+        int removeKey$kotlin_stdlib = removeKey$kotlin_stdlib(obj);
+        if (removeKey$kotlin_stdlib < 0) {
+            return null;
+        }
+        Object[] objArr = this.valuesArray;
+        Intrinsics.checkNotNull(objArr);
+        Object obj2 = objArr[removeKey$kotlin_stdlib];
+        ListBuilderKt.resetAt(objArr, removeKey$kotlin_stdlib);
+        return obj2;
+    }
+
+    @Override // java.util.Map
+    public void clear() {
+        checkIsMutable$kotlin_stdlib();
+        IntIterator it = new IntRange(0, this.length - 1).iterator();
+        while (it.hasNext()) {
+            int nextInt = it.nextInt();
+            int[] iArr = this.presenceArray;
+            int i = iArr[nextInt];
+            if (i >= 0) {
+                this.hashArray[i] = 0;
+                iArr[nextInt] = -1;
+            }
+        }
+        ListBuilderKt.resetRange(this.keysArray, 0, this.length);
+        Object[] objArr = this.valuesArray;
+        if (objArr != null) {
+            ListBuilderKt.resetRange(objArr, 0, this.length);
+        }
+        this.size = 0;
+        this.length = 0;
+        registerModification();
+    }
+
+    public Set getKeys() {
+        MapBuilderKeys mapBuilderKeys = this.keysView;
+        if (mapBuilderKeys != null) {
+            return mapBuilderKeys;
+        }
+        MapBuilderKeys mapBuilderKeys2 = new MapBuilderKeys(this);
+        this.keysView = mapBuilderKeys2;
+        return mapBuilderKeys2;
+    }
+
+    public Collection getValues() {
+        MapBuilderValues mapBuilderValues = this.valuesView;
+        if (mapBuilderValues != null) {
+            return mapBuilderValues;
+        }
+        MapBuilderValues mapBuilderValues2 = new MapBuilderValues(this);
+        this.valuesView = mapBuilderValues2;
+        return mapBuilderValues2;
+    }
+
+    public Set getEntries() {
+        MapBuilderEntries mapBuilderEntries = this.entriesView;
+        if (mapBuilderEntries != null) {
+            return mapBuilderEntries;
+        }
+        MapBuilderEntries mapBuilderEntries2 = new MapBuilderEntries(this);
+        this.entriesView = mapBuilderEntries2;
+        return mapBuilderEntries2;
+    }
+
+    @Override // java.util.Map
+    public boolean equals(Object obj) {
+        return obj == this || ((obj instanceof Map) && contentEquals((Map) obj));
+    }
+
+    @Override // java.util.Map
+    public int hashCode() {
+        EntriesItr entriesIterator$kotlin_stdlib = entriesIterator$kotlin_stdlib();
+        int i = 0;
+        while (entriesIterator$kotlin_stdlib.hasNext()) {
+            i += entriesIterator$kotlin_stdlib.nextHashCode$kotlin_stdlib();
+        }
+        return i;
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder((size() * 3) + 2);
+        sb.append("{");
+        EntriesItr entriesIterator$kotlin_stdlib = entriesIterator$kotlin_stdlib();
+        int i = 0;
+        while (entriesIterator$kotlin_stdlib.hasNext()) {
+            if (i > 0) {
+                sb.append(", ");
+            }
+            entriesIterator$kotlin_stdlib.nextAppendString(sb);
+            i++;
+        }
+        sb.append("}");
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "toString(...)");
+        return sb2;
+    }
+
+    public final int getCapacity$kotlin_stdlib() {
+        return this.keysArray.length;
+    }
+
+    public final int getHashSize() {
+        return this.hashArray.length;
+    }
+
+    public final void checkIsMutable$kotlin_stdlib() {
+        if (this.isReadOnly) {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    private final void ensureExtraCapacity(int i) {
+        if (shouldCompact(i)) {
+            rehash(getHashSize());
+        } else {
+            ensureCapacity(this.length + i);
+        }
+    }
+
+    public final boolean shouldCompact(int i) {
+        int capacity$kotlin_stdlib = getCapacity$kotlin_stdlib();
+        int i2 = this.length;
+        int i3 = capacity$kotlin_stdlib - i2;
+        int size = i2 - size();
+        return i3 < i && i3 + size >= i && size >= getCapacity$kotlin_stdlib() / 4;
+    }
+
+    private final void ensureCapacity(int i) {
+        if (i < 0) {
+            throw new OutOfMemoryError();
+        }
+        if (i > getCapacity$kotlin_stdlib()) {
+            int newCapacity$kotlin_stdlib = AbstractList.Companion.newCapacity$kotlin_stdlib(getCapacity$kotlin_stdlib(), i);
+            this.keysArray = ListBuilderKt.copyOfUninitializedElements(this.keysArray, newCapacity$kotlin_stdlib);
+            Object[] objArr = this.valuesArray;
+            this.valuesArray = objArr != null ? ListBuilderKt.copyOfUninitializedElements(objArr, newCapacity$kotlin_stdlib) : null;
+            int[] copyOf = Arrays.copyOf(this.presenceArray, newCapacity$kotlin_stdlib);
+            Intrinsics.checkNotNullExpressionValue(copyOf, "copyOf(...)");
+            this.presenceArray = copyOf;
+            int computeHashSize = Companion.computeHashSize(newCapacity$kotlin_stdlib);
+            if (computeHashSize > getHashSize()) {
+                rehash(computeHashSize);
+            }
+        }
+    }
+
+    public final Object[] allocateValuesArray() {
+        Object[] objArr = this.valuesArray;
+        if (objArr != null) {
+            return objArr;
+        }
+        Object[] arrayOfUninitializedElements = ListBuilderKt.arrayOfUninitializedElements(getCapacity$kotlin_stdlib());
+        this.valuesArray = arrayOfUninitializedElements;
+        return arrayOfUninitializedElements;
+    }
+
+    public final int hash(Object obj) {
+        return ((obj != null ? obj.hashCode() : 0) * (-1640531527)) >>> this.hashShift;
+    }
+
+    public final void compact() {
+        int i;
+        Object[] objArr = this.valuesArray;
+        int i2 = 0;
+        int i3 = 0;
+        while (true) {
+            i = this.length;
+            if (i2 >= i) {
+                break;
+            }
+            if (this.presenceArray[i2] >= 0) {
+                Object[] objArr2 = this.keysArray;
+                objArr2[i3] = objArr2[i2];
+                if (objArr != null) {
+                    objArr[i3] = objArr[i2];
+                }
+                i3++;
+            }
+            i2++;
+        }
+        ListBuilderKt.resetRange(this.keysArray, i3, i);
+        if (objArr != null) {
+            ListBuilderKt.resetRange(objArr, i3, this.length);
+        }
+        this.length = i3;
+    }
+
+    public final void rehash(int i) {
+        registerModification();
+        if (this.length > size()) {
+            compact();
+        }
+        int i2 = 0;
+        if (i != getHashSize()) {
+            this.hashArray = new int[i];
+            this.hashShift = Companion.computeShift(i);
+        } else {
+            ArraysKt___ArraysJvmKt.fill(this.hashArray, 0, 0, getHashSize());
+        }
+        while (i2 < this.length) {
+            int i3 = i2 + 1;
+            if (!putRehash(i2)) {
+                throw new IllegalStateException("This cannot happen with fixed magic multiplier and grow-only hash array. Have object hashCodes changed?");
+            }
+            i2 = i3;
+        }
+    }
+
+    public final boolean putRehash(int i) {
+        int hash = hash(this.keysArray[i]);
+        int i2 = this.maxProbeDistance;
+        while (true) {
+            int[] iArr = this.hashArray;
+            if (iArr[hash] == 0) {
+                iArr[hash] = i + 1;
+                this.presenceArray[i] = hash;
+                return true;
+            }
+            i2--;
+            if (i2 < 0) {
+                return false;
+            }
+            hash = hash == 0 ? getHashSize() - 1 : hash - 1;
+        }
+    }
+
+    public final int findKey(Object obj) {
+        int hash = hash(obj);
+        int i = this.maxProbeDistance;
+        while (true) {
+            int i2 = this.hashArray[hash];
+            if (i2 == 0) {
+                return -1;
+            }
+            if (i2 > 0) {
+                int i3 = i2 - 1;
+                if (Intrinsics.areEqual(this.keysArray[i3], obj)) {
+                    return i3;
+                }
+            }
+            i--;
+            if (i < 0) {
+                return -1;
+            }
+            hash = hash == 0 ? getHashSize() - 1 : hash - 1;
+        }
+    }
+
+    public final int findValue(Object obj) {
+        int i = this.length;
+        while (true) {
+            i--;
+            if (i < 0) {
+                return -1;
+            }
+            if (this.presenceArray[i] >= 0) {
+                Object[] objArr = this.valuesArray;
+                Intrinsics.checkNotNull(objArr);
+                if (Intrinsics.areEqual(objArr[i], obj)) {
+                    return i;
+                }
+            }
+        }
+    }
+
+    public final int addKey$kotlin_stdlib(Object obj) {
+        int coerceAtMost;
+        checkIsMutable$kotlin_stdlib();
+        while (true) {
+            int hash = hash(obj);
+            coerceAtMost = RangesKt___RangesKt.coerceAtMost(this.maxProbeDistance * 2, getHashSize() / 2);
+            int i = 0;
+            while (true) {
+                int i2 = this.hashArray[hash];
+                if (i2 <= 0) {
+                    if (this.length >= getCapacity$kotlin_stdlib()) {
+                        ensureExtraCapacity(1);
+                    } else {
+                        int i3 = this.length;
+                        int i4 = i3 + 1;
+                        this.length = i4;
+                        this.keysArray[i3] = obj;
+                        this.presenceArray[i3] = hash;
+                        this.hashArray[hash] = i4;
+                        this.size = size() + 1;
+                        registerModification();
+                        if (i > this.maxProbeDistance) {
+                            this.maxProbeDistance = i;
+                        }
+                        return i3;
+                    }
+                } else {
+                    if (Intrinsics.areEqual(this.keysArray[i2 - 1], obj)) {
+                        return -i2;
+                    }
+                    i++;
+                    if (i > coerceAtMost) {
+                        rehash(getHashSize() * 2);
+                        break;
+                    }
+                    hash = hash == 0 ? getHashSize() - 1 : hash - 1;
+                }
+            }
+        }
+    }
+
+    public final int removeKey$kotlin_stdlib(Object obj) {
+        checkIsMutable$kotlin_stdlib();
+        int findKey = findKey(obj);
+        if (findKey < 0) {
+            return -1;
+        }
+        removeKeyAt(findKey);
+        return findKey;
+    }
+
+    public final void removeKeyAt(int i) {
+        ListBuilderKt.resetAt(this.keysArray, i);
+        removeHashAt(this.presenceArray[i]);
+        this.presenceArray[i] = -1;
+        this.size = size() - 1;
+        registerModification();
+    }
+
+    public final void removeHashAt(int i) {
+        int coerceAtMost;
+        coerceAtMost = RangesKt___RangesKt.coerceAtMost(this.maxProbeDistance * 2, getHashSize() / 2);
+        int i2 = coerceAtMost;
+        int i3 = 0;
+        int i4 = i;
+        do {
+            i = i == 0 ? getHashSize() - 1 : i - 1;
+            i3++;
+            if (i3 > this.maxProbeDistance) {
+                this.hashArray[i4] = 0;
+                return;
+            }
+            int[] iArr = this.hashArray;
+            int i5 = iArr[i];
+            if (i5 == 0) {
+                iArr[i4] = 0;
+                return;
+            }
+            if (i5 < 0) {
+                iArr[i4] = -1;
+            } else {
+                int i6 = i5 - 1;
+                if (((hash(this.keysArray[i6]) - i) & (getHashSize() - 1)) >= i3) {
+                    this.hashArray[i4] = i5;
+                    this.presenceArray[i6] = i4;
+                }
+                i2--;
+            }
+            i4 = i;
+            i3 = 0;
+            i2--;
+        } while (i2 >= 0);
+        this.hashArray[i4] = -1;
+    }
+
+    public final boolean containsEntry$kotlin_stdlib(Map.Entry entry) {
+        Intrinsics.checkNotNullParameter(entry, "entry");
+        int findKey = findKey(entry.getKey());
+        if (findKey < 0) {
+            return false;
+        }
+        Object[] objArr = this.valuesArray;
+        Intrinsics.checkNotNull(objArr);
+        return Intrinsics.areEqual(objArr[findKey], entry.getValue());
+    }
+
+    public final boolean contentEquals(Map map) {
+        return size() == map.size() && containsAllEntries$kotlin_stdlib(map.entrySet());
+    }
+
+    public final boolean containsAllEntries$kotlin_stdlib(Collection m) {
+        Intrinsics.checkNotNullParameter(m, "m");
+        for (Object obj : m) {
+            if (obj != null) {
+                try {
+                    if (!containsEntry$kotlin_stdlib((Map.Entry) obj)) {
+                    }
+                } catch (ClassCastException unused) {
+                }
+            }
+            return false;
+        }
+        return true;
+    }
+
+    public final boolean putEntry(Map.Entry entry) {
+        int addKey$kotlin_stdlib = addKey$kotlin_stdlib(entry.getKey());
+        Object[] allocateValuesArray = allocateValuesArray();
+        if (addKey$kotlin_stdlib >= 0) {
+            allocateValuesArray[addKey$kotlin_stdlib] = entry.getValue();
+            return true;
+        }
+        int i = (-addKey$kotlin_stdlib) - 1;
+        if (Intrinsics.areEqual(entry.getValue(), allocateValuesArray[i])) {
+            return false;
+        }
+        allocateValuesArray[i] = entry.getValue();
+        return true;
+    }
+
+    public final boolean putAllEntries(Collection collection) {
+        boolean z = false;
+        if (collection.isEmpty()) {
+            return false;
+        }
+        ensureExtraCapacity(collection.size());
+        Iterator it = collection.iterator();
+        while (it.hasNext()) {
+            if (putEntry((Map.Entry) it.next())) {
+                z = true;
+            }
+        }
+        return z;
+    }
+
+    public final boolean removeEntry$kotlin_stdlib(Map.Entry entry) {
+        Intrinsics.checkNotNullParameter(entry, "entry");
+        checkIsMutable$kotlin_stdlib();
+        int findKey = findKey(entry.getKey());
+        if (findKey < 0) {
+            return false;
+        }
+        Object[] objArr = this.valuesArray;
+        Intrinsics.checkNotNull(objArr);
+        if (!Intrinsics.areEqual(objArr[findKey], entry.getValue())) {
+            return false;
+        }
+        removeKeyAt(findKey);
+        return true;
+    }
+
+    public final boolean removeValue$kotlin_stdlib(Object obj) {
+        checkIsMutable$kotlin_stdlib();
+        int findValue = findValue(obj);
+        if (findValue < 0) {
+            return false;
+        }
+        removeKeyAt(findValue);
+        return true;
+    }
+
+    public final KeysItr keysIterator$kotlin_stdlib() {
+        return new KeysItr(this);
+    }
+
+    public final ValuesItr valuesIterator$kotlin_stdlib() {
+        return new ValuesItr(this);
+    }
+
+    public final EntriesItr entriesIterator$kotlin_stdlib() {
+        return new EntriesItr(this);
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+
+        public final MapBuilder getEmpty$kotlin_stdlib() {
+            return MapBuilder.Empty;
+        }
+
+        public final int computeHashSize(int i) {
+            int coerceAtLeast;
+            coerceAtLeast = RangesKt___RangesKt.coerceAtLeast(i, 1);
+            return Integer.highestOneBit(coerceAtLeast * 3);
+        }
+
+        public final int computeShift(int i) {
+            return Integer.numberOfLeadingZeros(i) + 1;
+        }
+    }
+
+    static {
+        MapBuilder mapBuilder = new MapBuilder(0);
+        mapBuilder.isReadOnly = true;
+        Empty = mapBuilder;
+    }
+
+    public static class Itr {
+        public int expectedModCount;
+        public int index;
+        public int lastIndex;
+        public final MapBuilder map;
+
+        public final int getIndex$kotlin_stdlib() {
+            return this.index;
+        }
+
+        public final int getLastIndex$kotlin_stdlib() {
+            return this.lastIndex;
+        }
+
+        public final MapBuilder getMap$kotlin_stdlib() {
+            return this.map;
+        }
+
+        public final void setIndex$kotlin_stdlib(int i) {
+            this.index = i;
+        }
+
+        public final void setLastIndex$kotlin_stdlib(int i) {
+            this.lastIndex = i;
+        }
+
+        public Itr(MapBuilder map) {
+            Intrinsics.checkNotNullParameter(map, "map");
+            this.map = map;
+            this.lastIndex = -1;
+            this.expectedModCount = map.modCount;
+            initNext$kotlin_stdlib();
+        }
+
+        public final void initNext$kotlin_stdlib() {
+            while (this.index < this.map.length) {
+                int[] iArr = this.map.presenceArray;
+                int i = this.index;
+                if (iArr[i] >= 0) {
+                    return;
+                } else {
+                    this.index = i + 1;
+                }
+            }
+        }
+
+        public final boolean hasNext() {
+            return this.index < this.map.length;
+        }
+
+        public final void remove() {
+            checkForComodification$kotlin_stdlib();
+            if (this.lastIndex == -1) {
+                throw new IllegalStateException("Call next() before removing element from the iterator.".toString());
+            }
+            this.map.checkIsMutable$kotlin_stdlib();
+            this.map.removeKeyAt(this.lastIndex);
+            this.lastIndex = -1;
+            this.expectedModCount = this.map.modCount;
+        }
+
+        public final void checkForComodification$kotlin_stdlib() {
+            if (this.map.modCount != this.expectedModCount) {
+                throw new ConcurrentModificationException();
+            }
+        }
+    }
+
+    public static final class KeysItr extends Itr implements Iterator, KMutableIterator {
+        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+        public KeysItr(MapBuilder map) {
+            super(map);
+            Intrinsics.checkNotNullParameter(map, "map");
+        }
+
+        @Override // java.util.Iterator
+        public Object next() {
+            checkForComodification$kotlin_stdlib();
+            if (getIndex$kotlin_stdlib() >= getMap$kotlin_stdlib().length) {
+                throw new NoSuchElementException();
+            }
+            int index$kotlin_stdlib = getIndex$kotlin_stdlib();
+            setIndex$kotlin_stdlib(index$kotlin_stdlib + 1);
+            setLastIndex$kotlin_stdlib(index$kotlin_stdlib);
+            Object obj = getMap$kotlin_stdlib().keysArray[getLastIndex$kotlin_stdlib()];
+            initNext$kotlin_stdlib();
+            return obj;
+        }
+    }
+
+    public static final class ValuesItr extends Itr implements Iterator, KMutableIterator {
+        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+        public ValuesItr(MapBuilder map) {
+            super(map);
+            Intrinsics.checkNotNullParameter(map, "map");
+        }
+
+        @Override // java.util.Iterator
+        public Object next() {
+            checkForComodification$kotlin_stdlib();
+            if (getIndex$kotlin_stdlib() >= getMap$kotlin_stdlib().length) {
+                throw new NoSuchElementException();
+            }
+            int index$kotlin_stdlib = getIndex$kotlin_stdlib();
+            setIndex$kotlin_stdlib(index$kotlin_stdlib + 1);
+            setLastIndex$kotlin_stdlib(index$kotlin_stdlib);
+            Object[] objArr = getMap$kotlin_stdlib().valuesArray;
+            Intrinsics.checkNotNull(objArr);
+            Object obj = objArr[getLastIndex$kotlin_stdlib()];
+            initNext$kotlin_stdlib();
+            return obj;
+        }
+    }
+
+    public static final class EntriesItr extends Itr implements Iterator, KMutableIterator {
+        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+        public EntriesItr(MapBuilder map) {
+            super(map);
+            Intrinsics.checkNotNullParameter(map, "map");
+        }
+
+        @Override // java.util.Iterator
+        public EntryRef next() {
+            checkForComodification$kotlin_stdlib();
+            if (getIndex$kotlin_stdlib() >= getMap$kotlin_stdlib().length) {
+                throw new NoSuchElementException();
+            }
+            int index$kotlin_stdlib = getIndex$kotlin_stdlib();
+            setIndex$kotlin_stdlib(index$kotlin_stdlib + 1);
+            setLastIndex$kotlin_stdlib(index$kotlin_stdlib);
+            EntryRef entryRef = new EntryRef(getMap$kotlin_stdlib(), getLastIndex$kotlin_stdlib());
+            initNext$kotlin_stdlib();
+            return entryRef;
+        }
+
+        public final int nextHashCode$kotlin_stdlib() {
+            if (getIndex$kotlin_stdlib() >= getMap$kotlin_stdlib().length) {
+                throw new NoSuchElementException();
+            }
+            int index$kotlin_stdlib = getIndex$kotlin_stdlib();
+            setIndex$kotlin_stdlib(index$kotlin_stdlib + 1);
+            setLastIndex$kotlin_stdlib(index$kotlin_stdlib);
+            Object obj = getMap$kotlin_stdlib().keysArray[getLastIndex$kotlin_stdlib()];
+            int hashCode = obj != null ? obj.hashCode() : 0;
+            Object[] objArr = getMap$kotlin_stdlib().valuesArray;
+            Intrinsics.checkNotNull(objArr);
+            Object obj2 = objArr[getLastIndex$kotlin_stdlib()];
+            int hashCode2 = hashCode ^ (obj2 != null ? obj2.hashCode() : 0);
+            initNext$kotlin_stdlib();
+            return hashCode2;
+        }
+
+        public final void nextAppendString(StringBuilder sb) {
+            Intrinsics.checkNotNullParameter(sb, "sb");
+            if (getIndex$kotlin_stdlib() >= getMap$kotlin_stdlib().length) {
+                throw new NoSuchElementException();
+            }
+            int index$kotlin_stdlib = getIndex$kotlin_stdlib();
+            setIndex$kotlin_stdlib(index$kotlin_stdlib + 1);
+            setLastIndex$kotlin_stdlib(index$kotlin_stdlib);
+            Object obj = getMap$kotlin_stdlib().keysArray[getLastIndex$kotlin_stdlib()];
+            if (obj == getMap$kotlin_stdlib()) {
+                sb.append("(this Map)");
+            } else {
+                sb.append(obj);
+            }
+            sb.append(nb.T);
+            Object[] objArr = getMap$kotlin_stdlib().valuesArray;
+            Intrinsics.checkNotNull(objArr);
+            Object obj2 = objArr[getLastIndex$kotlin_stdlib()];
+            if (obj2 == getMap$kotlin_stdlib()) {
+                sb.append("(this Map)");
+            } else {
+                sb.append(obj2);
+            }
+            initNext$kotlin_stdlib();
+        }
+    }
+
+    public static final class EntryRef implements Map.Entry, KMutableMap.Entry {
+        public final int index;
+        public final MapBuilder map;
+
+        public EntryRef(MapBuilder map, int i) {
+            Intrinsics.checkNotNullParameter(map, "map");
+            this.map = map;
+            this.index = i;
+        }
+
+        @Override // java.util.Map.Entry
+        public Object getKey() {
+            return this.map.keysArray[this.index];
+        }
+
+        @Override // java.util.Map.Entry
+        public Object getValue() {
+            Object[] objArr = this.map.valuesArray;
+            Intrinsics.checkNotNull(objArr);
+            return objArr[this.index];
+        }
+
+        @Override // java.util.Map.Entry
+        public Object setValue(Object obj) {
+            this.map.checkIsMutable$kotlin_stdlib();
+            Object[] allocateValuesArray = this.map.allocateValuesArray();
+            int i = this.index;
+            Object obj2 = allocateValuesArray[i];
+            allocateValuesArray[i] = obj;
+            return obj2;
+        }
+
+        @Override // java.util.Map.Entry
+        public boolean equals(Object obj) {
+            if (obj instanceof Map.Entry) {
+                Map.Entry entry = (Map.Entry) obj;
+                if (Intrinsics.areEqual(entry.getKey(), getKey()) && Intrinsics.areEqual(entry.getValue(), getValue())) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        @Override // java.util.Map.Entry
+        public int hashCode() {
+            Object key = getKey();
+            int hashCode = key != null ? key.hashCode() : 0;
+            Object value = getValue();
+            return hashCode ^ (value != null ? value.hashCode() : 0);
+        }
+
+        public String toString() {
+            StringBuilder sb = new StringBuilder();
+            sb.append(getKey());
+            sb.append(nb.T);
+            sb.append(getValue());
+            return sb.toString();
+        }
+    }
+}

decompiled/sources/kotlin/collections/builders/MapBuilderEntries.java

@@ -0,0 +1,80 @@
+package kotlin.collections.builders;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class MapBuilderEntries extends AbstractMapBuilderEntrySet {
+    public final MapBuilder backing;
+
+    public MapBuilderEntries(MapBuilder backing) {
+        Intrinsics.checkNotNullParameter(backing, "backing");
+        this.backing = backing;
+    }
+
+    @Override // kotlin.collections.AbstractMutableSet
+    public int getSize() {
+        return this.backing.size();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean isEmpty() {
+        return this.backing.isEmpty();
+    }
+
+    @Override // kotlin.collections.builders.AbstractMapBuilderEntrySet
+    public boolean containsEntry(Map.Entry element) {
+        Intrinsics.checkNotNullParameter(element, "element");
+        return this.backing.containsEntry$kotlin_stdlib(element);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public void clear() {
+        this.backing.clear();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean add(Map.Entry element) {
+        Intrinsics.checkNotNullParameter(element, "element");
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean addAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // kotlin.collections.builders.AbstractMapBuilderEntrySet
+    public boolean remove(Map.Entry element) {
+        Intrinsics.checkNotNullParameter(element, "element");
+        return this.backing.removeEntry$kotlin_stdlib(element);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.Set
+    public Iterator iterator() {
+        return this.backing.entriesIterator$kotlin_stdlib();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean containsAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        return this.backing.containsAllEntries$kotlin_stdlib(elements);
+    }
+
+    @Override // java.util.AbstractSet, java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean removeAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        this.backing.checkIsMutable$kotlin_stdlib();
+        return super.removeAll(elements);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean retainAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        this.backing.checkIsMutable$kotlin_stdlib();
+        return super.retainAll(elements);
+    }
+}

decompiled/sources/kotlin/collections/builders/MapBuilderKeys.java

@@ -0,0 +1,73 @@
+package kotlin.collections.builders;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Set;
+import kotlin.collections.AbstractMutableSet;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.markers.KMutableSet;
+
+/* loaded from: classes5.dex */
+public final class MapBuilderKeys extends AbstractMutableSet implements Set, KMutableSet {
+    public final MapBuilder backing;
+
+    public MapBuilderKeys(MapBuilder backing) {
+        Intrinsics.checkNotNullParameter(backing, "backing");
+        this.backing = backing;
+    }
+
+    @Override // kotlin.collections.AbstractMutableSet
+    public int getSize() {
+        return this.backing.size();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean isEmpty() {
+        return this.backing.isEmpty();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean contains(Object obj) {
+        return this.backing.containsKey(obj);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public void clear() {
+        this.backing.clear();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean add(Object obj) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean addAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean remove(Object obj) {
+        return this.backing.removeKey$kotlin_stdlib(obj) >= 0;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.Set
+    public Iterator iterator() {
+        return this.backing.keysIterator$kotlin_stdlib();
+    }
+
+    @Override // java.util.AbstractSet, java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean removeAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        this.backing.checkIsMutable$kotlin_stdlib();
+        return super.removeAll(elements);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean retainAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        this.backing.checkIsMutable$kotlin_stdlib();
+        return super.retainAll(elements);
+    }
+}

decompiled/sources/kotlin/collections/builders/MapBuilderValues.java

@@ -0,0 +1,72 @@
+package kotlin.collections.builders;
+
+import java.util.Collection;
+import java.util.Iterator;
+import kotlin.collections.AbstractMutableCollection;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.markers.KMutableCollection;
+
+/* loaded from: classes5.dex */
+public final class MapBuilderValues extends AbstractMutableCollection implements Collection, KMutableCollection {
+    public final MapBuilder backing;
+
+    public MapBuilderValues(MapBuilder backing) {
+        Intrinsics.checkNotNullParameter(backing, "backing");
+        this.backing = backing;
+    }
+
+    @Override // kotlin.collections.AbstractMutableCollection
+    public int getSize() {
+        return this.backing.size();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection
+    public boolean isEmpty() {
+        return this.backing.isEmpty();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection
+    public boolean contains(Object obj) {
+        return this.backing.containsValue(obj);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection
+    public boolean add(Object obj) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection
+    public boolean addAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection
+    public void clear() {
+        this.backing.clear();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable
+    public Iterator iterator() {
+        return this.backing.valuesIterator$kotlin_stdlib();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection
+    public boolean remove(Object obj) {
+        return this.backing.removeValue$kotlin_stdlib(obj);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection
+    public boolean removeAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        this.backing.checkIsMutable$kotlin_stdlib();
+        return super.removeAll(elements);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection
+    public boolean retainAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        this.backing.checkIsMutable$kotlin_stdlib();
+        return super.retainAll(elements);
+    }
+}

decompiled/sources/kotlin/collections/builders/SerializedCollection.java

@@ -0,0 +1,90 @@
+package kotlin.collections.builders;
+
+import java.io.Externalizable;
+import java.io.InvalidObjectException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import kotlin.collections.CollectionsKt__CollectionsJVMKt;
+import kotlin.collections.SetsKt__SetsJVMKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class SerializedCollection implements Externalizable {
+    public static final Companion Companion = new Companion(null);
+    private static final long serialVersionUID = 0;
+    public Collection collection;
+    public final int tag;
+
+    private final Object readResolve() {
+        return this.collection;
+    }
+
+    public SerializedCollection(Collection collection, int i) {
+        Intrinsics.checkNotNullParameter(collection, "collection");
+        this.collection = collection;
+        this.tag = i;
+    }
+
+    @Override // java.io.Externalizable
+    public void writeExternal(ObjectOutput output) {
+        Intrinsics.checkNotNullParameter(output, "output");
+        output.writeByte(this.tag);
+        output.writeInt(this.collection.size());
+        Iterator it = this.collection.iterator();
+        while (it.hasNext()) {
+            output.writeObject(it.next());
+        }
+    }
+
+    @Override // java.io.Externalizable
+    public void readExternal(ObjectInput input) {
+        List createListBuilder;
+        List build;
+        List list;
+        Set createSetBuilder;
+        Intrinsics.checkNotNullParameter(input, "input");
+        byte readByte = input.readByte();
+        int i = readByte & 1;
+        if ((readByte & (-2)) != 0) {
+            throw new InvalidObjectException("Unsupported flags value: " + ((int) readByte) + '.');
+        }
+        int readInt = input.readInt();
+        if (readInt < 0) {
+            throw new InvalidObjectException("Illegal size value: " + readInt + '.');
+        }
+        int i2 = 0;
+        if (i == 0) {
+            createListBuilder = CollectionsKt__CollectionsJVMKt.createListBuilder(readInt);
+            while (i2 < readInt) {
+                createListBuilder.add(input.readObject());
+                i2++;
+            }
+            build = CollectionsKt__CollectionsJVMKt.build(createListBuilder);
+            list = build;
+        } else if (i == 1) {
+            createSetBuilder = SetsKt__SetsJVMKt.createSetBuilder(readInt);
+            while (i2 < readInt) {
+                createSetBuilder.add(input.readObject());
+                i2++;
+            }
+            list = SetsKt__SetsJVMKt.build(createSetBuilder);
+        } else {
+            throw new InvalidObjectException("Unsupported collection type tag: " + i + '.');
+        }
+        this.collection = list;
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+}

decompiled/sources/kotlin/collections/builders/SerializedMap.java

@@ -0,0 +1,67 @@
+package kotlin.collections.builders;
+
+import java.io.Externalizable;
+import java.io.InvalidObjectException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Map;
+import kotlin.collections.MapsKt__MapsJVMKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class SerializedMap implements Externalizable {
+    public static final Companion Companion = new Companion(null);
+    private static final long serialVersionUID = 0;
+    public Map map;
+
+    private final Object readResolve() {
+        return this.map;
+    }
+
+    public SerializedMap(Map map) {
+        Intrinsics.checkNotNullParameter(map, "map");
+        this.map = map;
+    }
+
+    @Override // java.io.Externalizable
+    public void writeExternal(ObjectOutput output) {
+        Intrinsics.checkNotNullParameter(output, "output");
+        output.writeByte(0);
+        output.writeInt(this.map.size());
+        for (Map.Entry entry : this.map.entrySet()) {
+            output.writeObject(entry.getKey());
+            output.writeObject(entry.getValue());
+        }
+    }
+
+    @Override // java.io.Externalizable
+    public void readExternal(ObjectInput input) {
+        Map createMapBuilder;
+        Map build;
+        Intrinsics.checkNotNullParameter(input, "input");
+        byte readByte = input.readByte();
+        if (readByte != 0) {
+            throw new InvalidObjectException("Unsupported flags value: " + ((int) readByte));
+        }
+        int readInt = input.readInt();
+        if (readInt < 0) {
+            throw new InvalidObjectException("Illegal size value: " + readInt + '.');
+        }
+        createMapBuilder = MapsKt__MapsJVMKt.createMapBuilder(readInt);
+        for (int i = 0; i < readInt; i++) {
+            createMapBuilder.put(input.readObject(), input.readObject());
+        }
+        build = MapsKt__MapsJVMKt.build(createMapBuilder);
+        this.map = build;
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+}

decompiled/sources/kotlin/collections/builders/SetBuilder.java

@@ -0,0 +1,108 @@
+package kotlin.collections.builders;
+
+import java.io.NotSerializableException;
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Set;
+import kotlin.collections.AbstractMutableSet;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.markers.KMutableSet;
+
+/* loaded from: classes5.dex */
+public final class SetBuilder extends AbstractMutableSet implements Set, Serializable, KMutableSet {
+    public static final Companion Companion = new Companion(null);
+    public static final SetBuilder Empty = new SetBuilder(MapBuilder.Companion.getEmpty$kotlin_stdlib());
+    public final MapBuilder backing;
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+
+    public SetBuilder(MapBuilder backing) {
+        Intrinsics.checkNotNullParameter(backing, "backing");
+        this.backing = backing;
+    }
+
+    public SetBuilder() {
+        this(new MapBuilder());
+    }
+
+    public SetBuilder(int i) {
+        this(new MapBuilder(i));
+    }
+
+    public final Set build() {
+        this.backing.build();
+        return size() > 0 ? this : Empty;
+    }
+
+    private final Object writeReplace() {
+        if (this.backing.isReadOnly$kotlin_stdlib()) {
+            return new SerializedCollection(this, 1);
+        }
+        throw new NotSerializableException("The set cannot be serialized while it is being built.");
+    }
+
+    @Override // kotlin.collections.AbstractMutableSet
+    public int getSize() {
+        return this.backing.size();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean isEmpty() {
+        return this.backing.isEmpty();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean contains(Object obj) {
+        return this.backing.containsKey(obj);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public void clear() {
+        this.backing.clear();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean add(Object obj) {
+        return this.backing.addKey$kotlin_stdlib(obj) >= 0;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean remove(Object obj) {
+        return this.backing.removeKey$kotlin_stdlib(obj) >= 0;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.Set
+    public Iterator iterator() {
+        return this.backing.keysIterator$kotlin_stdlib();
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean addAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        this.backing.checkIsMutable$kotlin_stdlib();
+        return super.addAll(elements);
+    }
+
+    @Override // java.util.AbstractSet, java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean removeAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        this.backing.checkIsMutable$kotlin_stdlib();
+        return super.removeAll(elements);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean retainAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        this.backing.checkIsMutable$kotlin_stdlib();
+        return super.retainAll(elements);
+    }
+}

decompiled/sources/kotlin/comparisons/ComparisonsKt.java

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

decompiled/sources/kotlin/comparisons/ComparisonsKt__ComparisonsKt.java

@@ -0,0 +1,39 @@
+package kotlin.comparisons;
+
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class ComparisonsKt__ComparisonsKt {
+    public static int compareValuesBy(Object obj, Object obj2, Function1... selectors) {
+        Intrinsics.checkNotNullParameter(selectors, "selectors");
+        if (selectors.length <= 0) {
+            throw new IllegalArgumentException("Failed requirement.".toString());
+        }
+        return compareValuesByImpl$ComparisonsKt__ComparisonsKt(obj, obj2, selectors);
+    }
+
+    public static final int compareValuesByImpl$ComparisonsKt__ComparisonsKt(Object obj, Object obj2, Function1[] function1Arr) {
+        int compareValues;
+        for (Function1 function1 : function1Arr) {
+            compareValues = compareValues((Comparable) function1.invoke(obj), (Comparable) function1.invoke(obj2));
+            if (compareValues != 0) {
+                return compareValues;
+            }
+        }
+        return 0;
+    }
+
+    public static int compareValues(Comparable comparable, Comparable comparable2) {
+        if (comparable == comparable2) {
+            return 0;
+        }
+        if (comparable == null) {
+            return -1;
+        }
+        if (comparable2 == null) {
+            return 1;
+        }
+        return comparable.compareTo(comparable2);
+    }
+}

decompiled/sources/kotlin/comparisons/ComparisonsKt___ComparisonsJvmKt.java

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

decompiled/sources/kotlin/comparisons/ComparisonsKt___ComparisonsKt.java

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

decompiled/sources/kotlin/coroutines/AbstractCoroutineContextElement.java

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

decompiled/sources/kotlin/coroutines/AbstractCoroutineContextKey.java

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

decompiled/sources/kotlin/coroutines/CombinedContext.java

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