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/jvm/JvmClassMappingKt.java

@@ -0,0 +1,96 @@
+package kotlin.jvm;
+
+import kotlin.jvm.internal.ClassBasedDeclarationContainer;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Reflection;
+import kotlin.reflect.KClass;
+
+/* loaded from: classes5.dex */
+public abstract class JvmClassMappingKt {
+    public static final Class getJavaClass(KClass kClass) {
+        Intrinsics.checkNotNullParameter(kClass, "<this>");
+        Class<?> jClass = ((ClassBasedDeclarationContainer) kClass).getJClass();
+        Intrinsics.checkNotNull(jClass, "null cannot be cast to non-null type java.lang.Class<T of kotlin.jvm.JvmClassMappingKt.<get-java>>");
+        return jClass;
+    }
+
+    /* JADX WARN: Failed to restore switch over string. Please report as a decompilation issue
+    java.lang.NullPointerException: Cannot invoke "java.util.List.iterator()" because the return value of "jadx.core.dex.visitors.regions.SwitchOverStringVisitor$SwitchData.getNewCases()" is null
+    	at jadx.core.dex.visitors.regions.SwitchOverStringVisitor.restoreSwitchOverString(SwitchOverStringVisitor.java:109)
+    	at jadx.core.dex.visitors.regions.SwitchOverStringVisitor.visitRegion(SwitchOverStringVisitor.java:66)
+    	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseIterativeStepInternal(DepthRegionTraversal.java:77)
+    	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseIterativeStepInternal(DepthRegionTraversal.java:82)
+     */
+    public static final Class getJavaObjectType(KClass kClass) {
+        Intrinsics.checkNotNullParameter(kClass, "<this>");
+        Class<?> jClass = ((ClassBasedDeclarationContainer) kClass).getJClass();
+        if (!jClass.isPrimitive()) {
+            Intrinsics.checkNotNull(jClass, "null cannot be cast to non-null type java.lang.Class<T of kotlin.jvm.JvmClassMappingKt.<get-javaObjectType>>");
+            return jClass;
+        }
+        String name = jClass.getName();
+        switch (name.hashCode()) {
+            case -1325958191:
+                if (name.equals("double")) {
+                    jClass = Double.class;
+                    break;
+                }
+                break;
+            case 104431:
+                if (name.equals("int")) {
+                    jClass = Integer.class;
+                    break;
+                }
+                break;
+            case 3039496:
+                if (name.equals("byte")) {
+                    jClass = Byte.class;
+                    break;
+                }
+                break;
+            case 3052374:
+                if (name.equals("char")) {
+                    jClass = Character.class;
+                    break;
+                }
+                break;
+            case 3327612:
+                if (name.equals("long")) {
+                    jClass = Long.class;
+                    break;
+                }
+                break;
+            case 3625364:
+                if (name.equals("void")) {
+                    jClass = Void.class;
+                    break;
+                }
+                break;
+            case 64711720:
+                if (name.equals("boolean")) {
+                    jClass = Boolean.class;
+                    break;
+                }
+                break;
+            case 97526364:
+                if (name.equals("float")) {
+                    jClass = Float.class;
+                    break;
+                }
+                break;
+            case 109413500:
+                if (name.equals("short")) {
+                    jClass = Short.class;
+                    break;
+                }
+                break;
+        }
+        Intrinsics.checkNotNull(jClass, "null cannot be cast to non-null type java.lang.Class<T of kotlin.jvm.JvmClassMappingKt.<get-javaObjectType>>");
+        return jClass;
+    }
+
+    public static final KClass getKotlinClass(Class cls) {
+        Intrinsics.checkNotNullParameter(cls, "<this>");
+        return Reflection.getOrCreateKotlinClass(cls);
+    }
+}

decompiled/sources/kotlin/jvm/JvmStatic.java

@@ -0,0 +1,23 @@
+package kotlin.jvm;
+
+import com.facebook.ads.redexgen.core.EnumC1344dI;
+import com.facebook.ads.redexgen.core.EnumC1345dJ;
+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.Metadata;
+import kotlin.annotation.MustBeDocumented;
+
+@Target({ElementType.METHOD})
+@kotlin.annotation.Target(allowedTargets = {EnumC1344dI.A0A, EnumC1344dI.A0C, EnumC1344dI.A0D, EnumC1344dI.A0E})
+@Retention(RetentionPolicy.RUNTIME)
+@kotlin.annotation.Retention(EnumC1345dJ.A05)
+@MustBeDocumented
+@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/jvm/JvmStatic;", "", "kotlin-stdlib"}, k = 1, mv = {1, 9, 0}, xi = TokenParametersOuterClass$TokenParameters.LOWPOWERMODE_FIELD_NUMBER)
+@Documented
+/* loaded from: assets/audience_network.dex */
+public @interface JvmStatic {
+}

decompiled/sources/kotlin/jvm/KotlinReflectionNotSupportedError.java

@@ -0,0 +1,8 @@
+package kotlin.jvm;
+
+/* loaded from: classes5.dex */
+public class KotlinReflectionNotSupportedError extends Error {
+    public KotlinReflectionNotSupportedError() {
+        super("Kotlin reflection implementation is not found at runtime. Make sure you have kotlin-reflect.jar in the classpath");
+    }
+}

decompiled/sources/kotlin/jvm/functions/Function0.java

@@ -0,0 +1,8 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function0 extends Function {
+    Object invoke();
+}

decompiled/sources/kotlin/jvm/functions/Function1.java

@@ -0,0 +1,8 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function1 extends Function {
+    Object invoke(Object obj);
+}

decompiled/sources/kotlin/jvm/functions/Function10.java

@@ -0,0 +1,7 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function10 extends Function {
+}

decompiled/sources/kotlin/jvm/functions/Function11.java

@@ -0,0 +1,7 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function11 extends Function {
+}

decompiled/sources/kotlin/jvm/functions/Function12.java

@@ -0,0 +1,7 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function12 extends Function {
+}

decompiled/sources/kotlin/jvm/functions/Function13.java

@@ -0,0 +1,7 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function13 extends Function {
+}

decompiled/sources/kotlin/jvm/functions/Function14.java

@@ -0,0 +1,7 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function14 extends Function {
+}

decompiled/sources/kotlin/jvm/functions/Function15.java

@@ -0,0 +1,7 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function15 extends Function {
+}

decompiled/sources/kotlin/jvm/functions/Function16.java

@@ -0,0 +1,7 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function16 extends Function {
+}

decompiled/sources/kotlin/jvm/functions/Function17.java

@@ -0,0 +1,7 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function17 extends Function {
+}

decompiled/sources/kotlin/jvm/functions/Function18.java

@@ -0,0 +1,7 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function18 extends Function {
+}

decompiled/sources/kotlin/jvm/functions/Function19.java

@@ -0,0 +1,7 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function19 extends Function {
+}

decompiled/sources/kotlin/jvm/functions/Function2.java

@@ -0,0 +1,8 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function2 extends Function {
+    Object invoke(Object obj, Object obj2);
+}

decompiled/sources/kotlin/jvm/functions/Function20.java

@@ -0,0 +1,7 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function20 extends Function {
+}

decompiled/sources/kotlin/jvm/functions/Function21.java

@@ -0,0 +1,7 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function21 extends Function {
+}

decompiled/sources/kotlin/jvm/functions/Function22.java

@@ -0,0 +1,7 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function22 extends Function {
+}

decompiled/sources/kotlin/jvm/functions/Function3.java

@@ -0,0 +1,8 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function3 extends Function {
+    Object invoke(Object obj, Object obj2, Object obj3);
+}

decompiled/sources/kotlin/jvm/functions/Function4.java

@@ -0,0 +1,8 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function4 extends Function {
+    Object invoke(Object obj, Object obj2, Object obj3, Object obj4);
+}

decompiled/sources/kotlin/jvm/functions/Function5.java

@@ -0,0 +1,7 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function5 extends Function {
+}

decompiled/sources/kotlin/jvm/functions/Function6.java

@@ -0,0 +1,8 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function6 extends Function {
+    Object invoke(Object obj, Object obj2, Object obj3, Object obj4, Object obj5, Object obj6);
+}

decompiled/sources/kotlin/jvm/functions/Function7.java

@@ -0,0 +1,7 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function7 extends Function {
+}

decompiled/sources/kotlin/jvm/functions/Function8.java

@@ -0,0 +1,7 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function8 extends Function {
+}

decompiled/sources/kotlin/jvm/functions/Function9.java

@@ -0,0 +1,7 @@
+package kotlin.jvm.functions;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface Function9 extends Function {
+}

decompiled/sources/kotlin/jvm/internal/AdaptedFunctionReference.java

@@ -0,0 +1,64 @@
+package kotlin.jvm.internal;
+
+import java.io.Serializable;
+import kotlin.reflect.KDeclarationContainer;
+
+/* loaded from: classes5.dex */
+public class AdaptedFunctionReference implements FunctionBase, Serializable {
+    private final int arity;
+    private final int flags;
+    private final boolean isTopLevel;
+    private final String name;
+    private final Class owner;
+    protected final Object receiver;
+    private final String signature;
+
+    @Override // kotlin.jvm.internal.FunctionBase
+    public int getArity() {
+        return this.arity;
+    }
+
+    public AdaptedFunctionReference(int i, Class cls, String str, String str2, int i2) {
+        this(i, CallableReference.NO_RECEIVER, cls, str, str2, i2);
+    }
+
+    public AdaptedFunctionReference(int i, Object obj, Class cls, String str, String str2, int i2) {
+        this.receiver = obj;
+        this.owner = cls;
+        this.name = str;
+        this.signature = str2;
+        this.isTopLevel = (i2 & 1) == 1;
+        this.arity = i;
+        this.flags = i2 >> 1;
+    }
+
+    public KDeclarationContainer getOwner() {
+        Class cls = this.owner;
+        if (cls == null) {
+            return null;
+        }
+        return this.isTopLevel ? Reflection.getOrCreateKotlinPackage(cls) : Reflection.getOrCreateKotlinClass(cls);
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof AdaptedFunctionReference)) {
+            return false;
+        }
+        AdaptedFunctionReference adaptedFunctionReference = (AdaptedFunctionReference) obj;
+        return this.isTopLevel == adaptedFunctionReference.isTopLevel && this.arity == adaptedFunctionReference.arity && this.flags == adaptedFunctionReference.flags && Intrinsics.areEqual(this.receiver, adaptedFunctionReference.receiver) && Intrinsics.areEqual(this.owner, adaptedFunctionReference.owner) && this.name.equals(adaptedFunctionReference.name) && this.signature.equals(adaptedFunctionReference.signature);
+    }
+
+    public int hashCode() {
+        Object obj = this.receiver;
+        int hashCode = (obj != null ? obj.hashCode() : 0) * 31;
+        Class cls = this.owner;
+        return ((((((((((hashCode + (cls != null ? cls.hashCode() : 0)) * 31) + this.name.hashCode()) * 31) + this.signature.hashCode()) * 31) + (this.isTopLevel ? 1231 : 1237)) * 31) + this.arity) * 31) + this.flags;
+    }
+
+    public String toString() {
+        return Reflection.renderLambdaToString(this);
+    }
+}

decompiled/sources/kotlin/jvm/internal/ArrayBooleanIterator.java

@@ -0,0 +1,33 @@
+package kotlin.jvm.internal;
+
+import java.util.NoSuchElementException;
+import kotlin.collections.BooleanIterator;
+
+/* loaded from: classes5.dex */
+final class ArrayBooleanIterator extends BooleanIterator {
+    private final boolean[] array;
+    private int index;
+
+    public ArrayBooleanIterator(boolean[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        this.array = array;
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.index < this.array.length;
+    }
+
+    @Override // kotlin.collections.BooleanIterator
+    public boolean nextBoolean() {
+        try {
+            boolean[] zArr = this.array;
+            int i = this.index;
+            this.index = i + 1;
+            return zArr[i];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            this.index--;
+            throw new NoSuchElementException(e.getMessage());
+        }
+    }
+}

decompiled/sources/kotlin/jvm/internal/ArrayByteIterator.java

@@ -0,0 +1,33 @@
+package kotlin.jvm.internal;
+
+import java.util.NoSuchElementException;
+import kotlin.collections.ByteIterator;
+
+/* loaded from: classes5.dex */
+final class ArrayByteIterator extends ByteIterator {
+    private final byte[] array;
+    private int index;
+
+    public ArrayByteIterator(byte[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        this.array = array;
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.index < this.array.length;
+    }
+
+    @Override // kotlin.collections.ByteIterator
+    public byte nextByte() {
+        try {
+            byte[] bArr = this.array;
+            int i = this.index;
+            this.index = i + 1;
+            return bArr[i];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            this.index--;
+            throw new NoSuchElementException(e.getMessage());
+        }
+    }
+}

decompiled/sources/kotlin/jvm/internal/ArrayCharIterator.java

@@ -0,0 +1,33 @@
+package kotlin.jvm.internal;
+
+import java.util.NoSuchElementException;
+import kotlin.collections.CharIterator;
+
+/* loaded from: classes5.dex */
+final class ArrayCharIterator extends CharIterator {
+    private final char[] array;
+    private int index;
+
+    public ArrayCharIterator(char[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        this.array = array;
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.index < this.array.length;
+    }
+
+    @Override // kotlin.collections.CharIterator
+    public char nextChar() {
+        try {
+            char[] cArr = this.array;
+            int i = this.index;
+            this.index = i + 1;
+            return cArr[i];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            this.index--;
+            throw new NoSuchElementException(e.getMessage());
+        }
+    }
+}

decompiled/sources/kotlin/jvm/internal/ArrayDoubleIterator.java

@@ -0,0 +1,33 @@
+package kotlin.jvm.internal;
+
+import java.util.NoSuchElementException;
+import kotlin.collections.DoubleIterator;
+
+/* loaded from: classes5.dex */
+final class ArrayDoubleIterator extends DoubleIterator {
+    private final double[] array;
+    private int index;
+
+    public ArrayDoubleIterator(double[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        this.array = array;
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.index < this.array.length;
+    }
+
+    @Override // kotlin.collections.DoubleIterator
+    public double nextDouble() {
+        try {
+            double[] dArr = this.array;
+            int i = this.index;
+            this.index = i + 1;
+            return dArr[i];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            this.index--;
+            throw new NoSuchElementException(e.getMessage());
+        }
+    }
+}

decompiled/sources/kotlin/jvm/internal/ArrayFloatIterator.java

@@ -0,0 +1,33 @@
+package kotlin.jvm.internal;
+
+import java.util.NoSuchElementException;
+import kotlin.collections.FloatIterator;
+
+/* loaded from: classes5.dex */
+final class ArrayFloatIterator extends FloatIterator {
+    private final float[] array;
+    private int index;
+
+    public ArrayFloatIterator(float[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        this.array = array;
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.index < this.array.length;
+    }
+
+    @Override // kotlin.collections.FloatIterator
+    public float nextFloat() {
+        try {
+            float[] fArr = this.array;
+            int i = this.index;
+            this.index = i + 1;
+            return fArr[i];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            this.index--;
+            throw new NoSuchElementException(e.getMessage());
+        }
+    }
+}

decompiled/sources/kotlin/jvm/internal/ArrayIntIterator.java

@@ -0,0 +1,33 @@
+package kotlin.jvm.internal;
+
+import java.util.NoSuchElementException;
+import kotlin.collections.IntIterator;
+
+/* loaded from: classes5.dex */
+final class ArrayIntIterator extends IntIterator {
+    private final int[] array;
+    private int index;
+
+    public ArrayIntIterator(int[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        this.array = array;
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.index < this.array.length;
+    }
+
+    @Override // kotlin.collections.IntIterator
+    public int nextInt() {
+        try {
+            int[] iArr = this.array;
+            int i = this.index;
+            this.index = i + 1;
+            return iArr[i];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            this.index--;
+            throw new NoSuchElementException(e.getMessage());
+        }
+    }
+}

decompiled/sources/kotlin/jvm/internal/ArrayIterator.java

@@ -0,0 +1,43 @@
+package kotlin.jvm.internal;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+final class ArrayIterator<T> implements Iterator<T>, KMappedMarker {
+    private final T[] array;
+    private int index;
+
+    public final T[] getArray() {
+        return this.array;
+    }
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    public ArrayIterator(T[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        this.array = array;
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.index < this.array.length;
+    }
+
+    @Override // java.util.Iterator
+    public T next() {
+        try {
+            T[] tArr = this.array;
+            int i = this.index;
+            this.index = i + 1;
+            return tArr[i];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            this.index--;
+            throw new NoSuchElementException(e.getMessage());
+        }
+    }
+}

decompiled/sources/kotlin/jvm/internal/ArrayIteratorKt.java

@@ -0,0 +1,11 @@
+package kotlin.jvm.internal;
+
+import java.util.Iterator;
+
+/* loaded from: classes5.dex */
+public final class ArrayIteratorKt {
+    public static final <T> Iterator<T> iterator(T[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        return new ArrayIterator(array);
+    }
+}

decompiled/sources/kotlin/jvm/internal/ArrayIteratorsKt.java

@@ -0,0 +1,53 @@
+package kotlin.jvm.internal;
+
+import kotlin.collections.BooleanIterator;
+import kotlin.collections.ByteIterator;
+import kotlin.collections.CharIterator;
+import kotlin.collections.DoubleIterator;
+import kotlin.collections.FloatIterator;
+import kotlin.collections.IntIterator;
+import kotlin.collections.LongIterator;
+import kotlin.collections.ShortIterator;
+
+/* loaded from: classes5.dex */
+public final class ArrayIteratorsKt {
+    public static final ByteIterator iterator(byte[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        return new ArrayByteIterator(array);
+    }
+
+    public static final CharIterator iterator(char[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        return new ArrayCharIterator(array);
+    }
+
+    public static final ShortIterator iterator(short[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        return new ArrayShortIterator(array);
+    }
+
+    public static final IntIterator iterator(int[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        return new ArrayIntIterator(array);
+    }
+
+    public static final LongIterator iterator(long[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        return new ArrayLongIterator(array);
+    }
+
+    public static final FloatIterator iterator(float[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        return new ArrayFloatIterator(array);
+    }
+
+    public static final DoubleIterator iterator(double[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        return new ArrayDoubleIterator(array);
+    }
+
+    public static final BooleanIterator iterator(boolean[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        return new ArrayBooleanIterator(array);
+    }
+}

decompiled/sources/kotlin/jvm/internal/ArrayLongIterator.java

@@ -0,0 +1,33 @@
+package kotlin.jvm.internal;
+
+import java.util.NoSuchElementException;
+import kotlin.collections.LongIterator;
+
+/* loaded from: classes5.dex */
+final class ArrayLongIterator extends LongIterator {
+    private final long[] array;
+    private int index;
+
+    public ArrayLongIterator(long[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        this.array = array;
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.index < this.array.length;
+    }
+
+    @Override // kotlin.collections.LongIterator
+    public long nextLong() {
+        try {
+            long[] jArr = this.array;
+            int i = this.index;
+            this.index = i + 1;
+            return jArr[i];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            this.index--;
+            throw new NoSuchElementException(e.getMessage());
+        }
+    }
+}

decompiled/sources/kotlin/jvm/internal/ArrayShortIterator.java

@@ -0,0 +1,33 @@
+package kotlin.jvm.internal;
+
+import java.util.NoSuchElementException;
+import kotlin.collections.ShortIterator;
+
+/* loaded from: classes5.dex */
+final class ArrayShortIterator extends ShortIterator {
+    private final short[] array;
+    private int index;
+
+    public ArrayShortIterator(short[] array) {
+        Intrinsics.checkNotNullParameter(array, "array");
+        this.array = array;
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.index < this.array.length;
+    }
+
+    @Override // kotlin.collections.ShortIterator
+    public short nextShort() {
+        try {
+            short[] sArr = this.array;
+            int i = this.index;
+            this.index = i + 1;
+            return sArr[i];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            this.index--;
+            throw new NoSuchElementException(e.getMessage());
+        }
+    }
+}

decompiled/sources/kotlin/jvm/internal/BooleanCompanionObject.java

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

decompiled/sources/kotlin/jvm/internal/BooleanSpreadBuilder.java

@@ -0,0 +1,28 @@
+package kotlin.jvm.internal;
+
+/* loaded from: classes5.dex */
+public final class BooleanSpreadBuilder extends PrimitiveSpreadBuilder<boolean[]> {
+    private final boolean[] values;
+
+    public BooleanSpreadBuilder(int i) {
+        super(i);
+        this.values = new boolean[i];
+    }
+
+    @Override // kotlin.jvm.internal.PrimitiveSpreadBuilder
+    public int getSize(boolean[] zArr) {
+        Intrinsics.checkNotNullParameter(zArr, "<this>");
+        return zArr.length;
+    }
+
+    public final void add(boolean z) {
+        boolean[] zArr = this.values;
+        int position = getPosition();
+        setPosition(position + 1);
+        zArr[position] = z;
+    }
+
+    public final boolean[] toArray() {
+        return toArray(this.values, new boolean[size()]);
+    }
+}

decompiled/sources/kotlin/jvm/internal/ByteCompanionObject.java

@@ -0,0 +1,19 @@
+package kotlin.jvm.internal;
+
+/* loaded from: classes5.dex */
+public final class ByteCompanionObject {
+    public static final ByteCompanionObject INSTANCE = new ByteCompanionObject();
+    public static final byte MAX_VALUE = Byte.MAX_VALUE;
+    public static final byte MIN_VALUE = Byte.MIN_VALUE;
+    public static final int SIZE_BITS = 8;
+    public static final int SIZE_BYTES = 1;
+
+    public static /* synthetic */ void getSIZE_BITS$annotations() {
+    }
+
+    public static /* synthetic */ void getSIZE_BYTES$annotations() {
+    }
+
+    private ByteCompanionObject() {
+    }
+}

decompiled/sources/kotlin/jvm/internal/ByteSpreadBuilder.java

@@ -0,0 +1,28 @@
+package kotlin.jvm.internal;
+
+/* loaded from: classes5.dex */
+public final class ByteSpreadBuilder extends PrimitiveSpreadBuilder<byte[]> {
+    private final byte[] values;
+
+    public ByteSpreadBuilder(int i) {
+        super(i);
+        this.values = new byte[i];
+    }
+
+    @Override // kotlin.jvm.internal.PrimitiveSpreadBuilder
+    public int getSize(byte[] bArr) {
+        Intrinsics.checkNotNullParameter(bArr, "<this>");
+        return bArr.length;
+    }
+
+    public final void add(byte b) {
+        byte[] bArr = this.values;
+        int position = getPosition();
+        setPosition(position + 1);
+        bArr[position] = b;
+    }
+
+    public final byte[] toArray() {
+        return toArray(this.values, new byte[size()]);
+    }
+}

decompiled/sources/kotlin/jvm/internal/CallableReference.java

@@ -0,0 +1,146 @@
+package kotlin.jvm.internal;
+
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+import java.lang.annotation.Annotation;
+import java.util.List;
+import java.util.Map;
+import kotlin.jvm.KotlinReflectionNotSupportedError;
+import kotlin.reflect.KCallable;
+import kotlin.reflect.KDeclarationContainer;
+import kotlin.reflect.KType;
+import kotlin.reflect.KTypeParameter;
+import kotlin.reflect.KVisibility;
+
+/* loaded from: classes5.dex */
+public abstract class CallableReference implements KCallable, Serializable {
+    public static final Object NO_RECEIVER = NoReceiver.INSTANCE;
+    private final boolean isTopLevel;
+    private final String name;
+    private final Class owner;
+    protected final Object receiver;
+    private transient KCallable reflected;
+    private final String signature;
+
+    public abstract KCallable computeReflected();
+
+    public Object getBoundReceiver() {
+        return this.receiver;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public String getSignature() {
+        return this.signature;
+    }
+
+    public static class NoReceiver implements Serializable {
+        private static final NoReceiver INSTANCE = new NoReceiver();
+
+        private Object readResolve() throws ObjectStreamException {
+            return INSTANCE;
+        }
+
+        private NoReceiver() {
+        }
+    }
+
+    public CallableReference() {
+        this(NO_RECEIVER);
+    }
+
+    public CallableReference(Object obj) {
+        this(obj, null, null, null, false);
+    }
+
+    public CallableReference(Object obj, Class cls, String str, String str2, boolean z) {
+        this.receiver = obj;
+        this.owner = cls;
+        this.name = str;
+        this.signature = str2;
+        this.isTopLevel = z;
+    }
+
+    public KCallable compute() {
+        KCallable kCallable = this.reflected;
+        if (kCallable != null) {
+            return kCallable;
+        }
+        KCallable computeReflected = computeReflected();
+        this.reflected = computeReflected;
+        return computeReflected;
+    }
+
+    public KCallable getReflected() {
+        KCallable compute = compute();
+        if (compute != this) {
+            return compute;
+        }
+        throw new KotlinReflectionNotSupportedError();
+    }
+
+    public KDeclarationContainer getOwner() {
+        Class cls = this.owner;
+        if (cls == null) {
+            return null;
+        }
+        return this.isTopLevel ? Reflection.getOrCreateKotlinPackage(cls) : Reflection.getOrCreateKotlinClass(cls);
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public List<Object> getParameters() {
+        return getReflected().getParameters();
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public KType getReturnType() {
+        return getReflected().getReturnType();
+    }
+
+    @Override // kotlin.reflect.KAnnotatedElement
+    public List<Annotation> getAnnotations() {
+        return getReflected().getAnnotations();
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public List<KTypeParameter> getTypeParameters() {
+        return getReflected().getTypeParameters();
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public Object call(Object... objArr) {
+        return getReflected().call(objArr);
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public Object callBy(Map map) {
+        return getReflected().callBy(map);
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public KVisibility getVisibility() {
+        return getReflected().getVisibility();
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public boolean isFinal() {
+        return getReflected().isFinal();
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public boolean isOpen() {
+        return getReflected().isOpen();
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public boolean isAbstract() {
+        return getReflected().isAbstract();
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public boolean isSuspend() {
+        return getReflected().isSuspend();
+    }
+}

decompiled/sources/kotlin/jvm/internal/CharCompanionObject.java

@@ -0,0 +1,31 @@
+package kotlin.jvm.internal;
+
+/* loaded from: classes5.dex */
+public final class CharCompanionObject {
+    public static final CharCompanionObject INSTANCE = new CharCompanionObject();
+    public static final char MAX_HIGH_SURROGATE = 56319;
+    public static final char MAX_LOW_SURROGATE = 57343;
+    public static final char MAX_SURROGATE = 57343;
+    public static final char MAX_VALUE = 65535;
+    public static final char MIN_HIGH_SURROGATE = 55296;
+    public static final char MIN_LOW_SURROGATE = 56320;
+    public static final char MIN_SURROGATE = 55296;
+    public static final char MIN_VALUE = 0;
+    public static final int SIZE_BITS = 16;
+    public static final int SIZE_BYTES = 2;
+
+    public static /* synthetic */ void getMAX_VALUE$annotations() {
+    }
+
+    public static /* synthetic */ void getMIN_VALUE$annotations() {
+    }
+
+    public static /* synthetic */ void getSIZE_BITS$annotations() {
+    }
+
+    public static /* synthetic */ void getSIZE_BYTES$annotations() {
+    }
+
+    private CharCompanionObject() {
+    }
+}

decompiled/sources/kotlin/jvm/internal/CharSpreadBuilder.java

@@ -0,0 +1,28 @@
+package kotlin.jvm.internal;
+
+/* loaded from: classes5.dex */
+public final class CharSpreadBuilder extends PrimitiveSpreadBuilder<char[]> {
+    private final char[] values;
+
+    public CharSpreadBuilder(int i) {
+        super(i);
+        this.values = new char[i];
+    }
+
+    @Override // kotlin.jvm.internal.PrimitiveSpreadBuilder
+    public int getSize(char[] cArr) {
+        Intrinsics.checkNotNullParameter(cArr, "<this>");
+        return cArr.length;
+    }
+
+    public final void add(char c) {
+        char[] cArr = this.values;
+        int position = getPosition();
+        setPosition(position + 1);
+        cArr[position] = c;
+    }
+
+    public final char[] toArray() {
+        return toArray(this.values, new char[size()]);
+    }
+}

decompiled/sources/kotlin/jvm/internal/ClassBasedDeclarationContainer.java

@@ -0,0 +1,11 @@
+package kotlin.jvm.internal;
+
+import java.util.Collection;
+import kotlin.reflect.KDeclarationContainer;
+
+/* loaded from: classes5.dex */
+public interface ClassBasedDeclarationContainer extends KDeclarationContainer {
+    Class<?> getJClass();
+
+    /* synthetic */ Collection getMembers();
+}

decompiled/sources/kotlin/jvm/internal/ClassReference.java

@@ -0,0 +1,451 @@
+package kotlin.jvm.internal;
+
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import kotlin.Function;
+import kotlin.KotlinNothingValueException;
+import kotlin.Pair;
+import kotlin.TuplesKt;
+import kotlin.collections.CollectionsKt__CollectionsKt;
+import kotlin.collections.CollectionsKt__IterablesKt;
+import kotlin.collections.MapsKt__MapsJVMKt;
+import kotlin.collections.MapsKt__MapsKt;
+import kotlin.jvm.JvmClassMappingKt;
+import kotlin.jvm.KotlinReflectionNotSupportedError;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function10;
+import kotlin.jvm.functions.Function11;
+import kotlin.jvm.functions.Function12;
+import kotlin.jvm.functions.Function13;
+import kotlin.jvm.functions.Function14;
+import kotlin.jvm.functions.Function15;
+import kotlin.jvm.functions.Function16;
+import kotlin.jvm.functions.Function17;
+import kotlin.jvm.functions.Function18;
+import kotlin.jvm.functions.Function19;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.functions.Function20;
+import kotlin.jvm.functions.Function21;
+import kotlin.jvm.functions.Function22;
+import kotlin.jvm.functions.Function3;
+import kotlin.jvm.functions.Function4;
+import kotlin.jvm.functions.Function5;
+import kotlin.jvm.functions.Function6;
+import kotlin.jvm.functions.Function7;
+import kotlin.jvm.functions.Function8;
+import kotlin.jvm.functions.Function9;
+import kotlin.reflect.KCallable;
+import kotlin.reflect.KClass;
+import kotlin.reflect.KFunction;
+import kotlin.reflect.KType;
+import kotlin.reflect.KTypeParameter;
+import kotlin.reflect.KVisibility;
+import kotlin.text.StringsKt__StringsKt;
+
+@SourceDebugExtension({"SMAP\nClassReference.kt\nKotlin\n*S Kotlin\n*F\n+ 1 ClassReference.kt\nkotlin/jvm/internal/ClassReference\n+ 2 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n+ 3 Maps.kt\nkotlin/collections/MapsKt__MapsKt\n*L\n1#1,205:1\n1559#2:206\n1590#2,4:207\n1253#2,4:211\n1238#2,4:217\n453#3:215\n403#3:216\n*S KotlinDebug\n*F\n+ 1 ClassReference.kt\nkotlin/jvm/internal/ClassReference\n*L\n107#1:206\n107#1:207,4\n155#1:211,4\n163#1:217,4\n163#1:215\n163#1:216\n*E\n"})
+/* loaded from: classes5.dex */
+public final class ClassReference implements KClass, ClassBasedDeclarationContainer {
+    public static final Companion Companion = new Companion(null);
+    private static final Map<Class<? extends Function>, Integer> FUNCTION_CLASSES;
+    private static final HashMap<String, String> classFqNames;
+    private static final HashMap<String, String> primitiveFqNames;
+    private static final HashMap<String, String> primitiveWrapperFqNames;
+    private static final Map<String, String> simpleNames;
+    private final Class<?> jClass;
+
+    public static /* synthetic */ void getSealedSubclasses$annotations() {
+    }
+
+    public static /* synthetic */ void getSupertypes$annotations() {
+    }
+
+    public static /* synthetic */ void getTypeParameters$annotations() {
+    }
+
+    public static /* synthetic */ void getVisibility$annotations() {
+    }
+
+    public static /* synthetic */ void isAbstract$annotations() {
+    }
+
+    public static /* synthetic */ void isCompanion$annotations() {
+    }
+
+    public static /* synthetic */ void isData$annotations() {
+    }
+
+    public static /* synthetic */ void isFinal$annotations() {
+    }
+
+    public static /* synthetic */ void isFun$annotations() {
+    }
+
+    public static /* synthetic */ void isInner$annotations() {
+    }
+
+    public static /* synthetic */ void isOpen$annotations() {
+    }
+
+    public static /* synthetic */ void isSealed$annotations() {
+    }
+
+    public static /* synthetic */ void isValue$annotations() {
+    }
+
+    @Override // kotlin.jvm.internal.ClassBasedDeclarationContainer
+    public Class<?> getJClass() {
+        return this.jClass;
+    }
+
+    public ClassReference(Class<?> jClass) {
+        Intrinsics.checkNotNullParameter(jClass, "jClass");
+        this.jClass = jClass;
+    }
+
+    @Override // kotlin.reflect.KClass
+    public String getSimpleName() {
+        return Companion.getClassSimpleName(getJClass());
+    }
+
+    @Override // kotlin.reflect.KClass
+    public String getQualifiedName() {
+        return Companion.getClassQualifiedName(getJClass());
+    }
+
+    @Override // kotlin.jvm.internal.ClassBasedDeclarationContainer
+    public Collection<KCallable> getMembers() {
+        error();
+        throw new KotlinNothingValueException();
+    }
+
+    public Collection<KFunction> getConstructors() {
+        error();
+        throw new KotlinNothingValueException();
+    }
+
+    public Collection<KClass> getNestedClasses() {
+        error();
+        throw new KotlinNothingValueException();
+    }
+
+    @Override // kotlin.reflect.KAnnotatedElement
+    public List<Annotation> getAnnotations() {
+        error();
+        throw new KotlinNothingValueException();
+    }
+
+    public Object getObjectInstance() {
+        error();
+        throw new KotlinNothingValueException();
+    }
+
+    public boolean isInstance(Object obj) {
+        return Companion.isInstance(obj, getJClass());
+    }
+
+    public List<KTypeParameter> getTypeParameters() {
+        error();
+        throw new KotlinNothingValueException();
+    }
+
+    public List<KType> getSupertypes() {
+        error();
+        throw new KotlinNothingValueException();
+    }
+
+    public List<KClass> getSealedSubclasses() {
+        error();
+        throw new KotlinNothingValueException();
+    }
+
+    public KVisibility getVisibility() {
+        error();
+        throw new KotlinNothingValueException();
+    }
+
+    public boolean isFinal() {
+        error();
+        throw new KotlinNothingValueException();
+    }
+
+    public boolean isOpen() {
+        error();
+        throw new KotlinNothingValueException();
+    }
+
+    public boolean isAbstract() {
+        error();
+        throw new KotlinNothingValueException();
+    }
+
+    public boolean isSealed() {
+        error();
+        throw new KotlinNothingValueException();
+    }
+
+    public boolean isData() {
+        error();
+        throw new KotlinNothingValueException();
+    }
+
+    public boolean isInner() {
+        error();
+        throw new KotlinNothingValueException();
+    }
+
+    public boolean isCompanion() {
+        error();
+        throw new KotlinNothingValueException();
+    }
+
+    public boolean isFun() {
+        error();
+        throw new KotlinNothingValueException();
+    }
+
+    public boolean isValue() {
+        error();
+        throw new KotlinNothingValueException();
+    }
+
+    private final Void error() {
+        throw new KotlinReflectionNotSupportedError();
+    }
+
+    public boolean equals(Object obj) {
+        return (obj instanceof ClassReference) && Intrinsics.areEqual(JvmClassMappingKt.getJavaObjectType(this), JvmClassMappingKt.getJavaObjectType((KClass) obj));
+    }
+
+    public int hashCode() {
+        return JvmClassMappingKt.getJavaObjectType(this).hashCode();
+    }
+
+    public String toString() {
+        return getJClass().toString() + " (Kotlin reflection is not available)";
+    }
+
+    @SourceDebugExtension({"SMAP\nClassReference.kt\nKotlin\n*S Kotlin\n*F\n+ 1 ClassReference.kt\nkotlin/jvm/internal/ClassReference$Companion\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,205:1\n1#2:206\n*E\n"})
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        /* JADX WARN: Code restructure failed: missing block: B:8:0x003b, code lost:
+        
+            if (r2 == null) goto L13;
+         */
+        /*
+            Code decompiled incorrectly, please refer to instructions dump.
+            To view partially-correct add '--show-bad-code' argument
+        */
+        public final java.lang.String getClassSimpleName(java.lang.Class<?> r7) {
+            /*
+                r6 = this;
+                java.lang.String r0 = "jClass"
+                kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r7, r0)
+                boolean r0 = r7.isAnonymousClass()
+                r1 = 0
+                if (r0 == 0) goto Le
+                goto Lb3
+            Le:
+                boolean r0 = r7.isLocalClass()
+                if (r0 == 0) goto L6a
+                java.lang.String r0 = r7.getSimpleName()
+                java.lang.reflect.Method r2 = r7.getEnclosingMethod()
+                r3 = 2
+                r4 = 36
+                if (r2 == 0) goto L41
+                kotlin.jvm.internal.Intrinsics.checkNotNull(r0)
+                java.lang.StringBuilder r5 = new java.lang.StringBuilder
+                r5.<init>()
+                java.lang.String r2 = r2.getName()
+                r5.append(r2)
+                r5.append(r4)
+                java.lang.String r2 = r5.toString()
+                java.lang.String r2 = kotlin.text.StringsKt.substringAfter$default(r0, r2, r1, r3, r1)
+                if (r2 != 0) goto L3e
+                goto L41
+            L3e:
+                r1 = r2
+                goto Lb3
+            L41:
+                java.lang.reflect.Constructor r7 = r7.getEnclosingConstructor()
+                if (r7 == 0) goto L62
+                kotlin.jvm.internal.Intrinsics.checkNotNull(r0)
+                java.lang.StringBuilder r2 = new java.lang.StringBuilder
+                r2.<init>()
+                java.lang.String r7 = r7.getName()
+                r2.append(r7)
+                r2.append(r4)
+                java.lang.String r7 = r2.toString()
+                java.lang.String r1 = kotlin.text.StringsKt.substringAfter$default(r0, r7, r1, r3, r1)
+                goto Lb3
+            L62:
+                kotlin.jvm.internal.Intrinsics.checkNotNull(r0)
+                java.lang.String r1 = kotlin.text.StringsKt.substringAfter$default(r0, r4, r1, r3, r1)
+                goto Lb3
+            L6a:
+                boolean r0 = r7.isArray()
+                if (r0 == 0) goto L9e
+                java.lang.Class r7 = r7.getComponentType()
+                boolean r0 = r7.isPrimitive()
+                java.lang.String r2 = "Array"
+                if (r0 == 0) goto L9b
+                java.util.Map r0 = kotlin.jvm.internal.ClassReference.access$getSimpleNames$cp()
+                java.lang.String r7 = r7.getName()
+                java.lang.Object r7 = r0.get(r7)
+                java.lang.String r7 = (java.lang.String) r7
+                if (r7 == 0) goto L9b
+                java.lang.StringBuilder r0 = new java.lang.StringBuilder
+                r0.<init>()
+                r0.append(r7)
+                r0.append(r2)
+                java.lang.String r1 = r0.toString()
+            L9b:
+                if (r1 != 0) goto Lb3
+                goto L3e
+            L9e:
+                java.util.Map r0 = kotlin.jvm.internal.ClassReference.access$getSimpleNames$cp()
+                java.lang.String r1 = r7.getName()
+                java.lang.Object r0 = r0.get(r1)
+                r1 = r0
+                java.lang.String r1 = (java.lang.String) r1
+                if (r1 != 0) goto Lb3
+                java.lang.String r1 = r7.getSimpleName()
+            Lb3:
+                return r1
+            */
+            throw new UnsupportedOperationException("Method not decompiled: kotlin.jvm.internal.ClassReference.Companion.getClassSimpleName(java.lang.Class):java.lang.String");
+        }
+
+        public final String getClassQualifiedName(Class<?> jClass) {
+            String str;
+            Intrinsics.checkNotNullParameter(jClass, "jClass");
+            String str2 = null;
+            if (jClass.isAnonymousClass() || jClass.isLocalClass()) {
+                return null;
+            }
+            if (jClass.isArray()) {
+                Class<?> componentType = jClass.getComponentType();
+                if (componentType.isPrimitive() && (str = (String) ClassReference.classFqNames.get(componentType.getName())) != null) {
+                    str2 = str + "Array";
+                }
+                return str2 == null ? "kotlin.Array" : str2;
+            }
+            String str3 = (String) ClassReference.classFqNames.get(jClass.getName());
+            return str3 == null ? jClass.getCanonicalName() : str3;
+        }
+
+        public final boolean isInstance(Object obj, Class<?> jClass) {
+            Intrinsics.checkNotNullParameter(jClass, "jClass");
+            Map map = ClassReference.FUNCTION_CLASSES;
+            Intrinsics.checkNotNull(map, "null cannot be cast to non-null type kotlin.collections.Map<K of kotlin.collections.MapsKt__MapsKt.get, V of kotlin.collections.MapsKt__MapsKt.get>");
+            Integer num = (Integer) map.get(jClass);
+            if (num != null) {
+                return TypeIntrinsics.isFunctionOfArity(obj, num.intValue());
+            }
+            if (jClass.isPrimitive()) {
+                jClass = JvmClassMappingKt.getJavaObjectType(JvmClassMappingKt.getKotlinClass(jClass));
+            }
+            return jClass.isInstance(obj);
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    static {
+        List listOf;
+        Map<Class<? extends Function>, Integer> map;
+        int mapCapacity;
+        String substringAfterLast$default;
+        String substringAfterLast$default2;
+        int i = 0;
+        listOf = CollectionsKt__CollectionsKt.listOf((Object[]) new Class[]{Function0.class, Function1.class, Function2.class, Function3.class, Function4.class, Function5.class, Function6.class, Function7.class, Function8.class, Function9.class, Function10.class, Function11.class, Function12.class, Function13.class, Function14.class, Function15.class, Function16.class, Function17.class, Function18.class, Function19.class, Function20.class, Function21.class, Function22.class});
+        List list = listOf;
+        ArrayList arrayList = new ArrayList(CollectionsKt__IterablesKt.collectionSizeOrDefault(list, 10));
+        for (Object obj : list) {
+            int i2 = i + 1;
+            if (i < 0) {
+                CollectionsKt__CollectionsKt.throwIndexOverflow();
+            }
+            arrayList.add(TuplesKt.to((Class) obj, Integer.valueOf(i)));
+            i = i2;
+        }
+        map = MapsKt__MapsKt.toMap(arrayList);
+        FUNCTION_CLASSES = map;
+        HashMap<String, String> hashMap = new HashMap<>();
+        hashMap.put("boolean", "kotlin.Boolean");
+        hashMap.put("char", "kotlin.Char");
+        hashMap.put("byte", "kotlin.Byte");
+        hashMap.put("short", "kotlin.Short");
+        hashMap.put("int", "kotlin.Int");
+        hashMap.put("float", "kotlin.Float");
+        hashMap.put("long", "kotlin.Long");
+        hashMap.put("double", "kotlin.Double");
+        primitiveFqNames = hashMap;
+        HashMap<String, String> hashMap2 = new HashMap<>();
+        hashMap2.put("java.lang.Boolean", "kotlin.Boolean");
+        hashMap2.put("java.lang.Character", "kotlin.Char");
+        hashMap2.put("java.lang.Byte", "kotlin.Byte");
+        hashMap2.put("java.lang.Short", "kotlin.Short");
+        hashMap2.put("java.lang.Integer", "kotlin.Int");
+        hashMap2.put("java.lang.Float", "kotlin.Float");
+        hashMap2.put("java.lang.Long", "kotlin.Long");
+        hashMap2.put("java.lang.Double", "kotlin.Double");
+        primitiveWrapperFqNames = hashMap2;
+        HashMap<String, String> hashMap3 = new HashMap<>();
+        hashMap3.put("java.lang.Object", "kotlin.Any");
+        hashMap3.put("java.lang.String", "kotlin.String");
+        hashMap3.put("java.lang.CharSequence", "kotlin.CharSequence");
+        hashMap3.put("java.lang.Throwable", "kotlin.Throwable");
+        hashMap3.put("java.lang.Cloneable", "kotlin.Cloneable");
+        hashMap3.put("java.lang.Number", "kotlin.Number");
+        hashMap3.put("java.lang.Comparable", "kotlin.Comparable");
+        hashMap3.put("java.lang.Enum", "kotlin.Enum");
+        hashMap3.put("java.lang.annotation.Annotation", "kotlin.Annotation");
+        hashMap3.put("java.lang.Iterable", "kotlin.collections.Iterable");
+        hashMap3.put("java.util.Iterator", "kotlin.collections.Iterator");
+        hashMap3.put("java.util.Collection", "kotlin.collections.Collection");
+        hashMap3.put("java.util.List", "kotlin.collections.List");
+        hashMap3.put("java.util.Set", "kotlin.collections.Set");
+        hashMap3.put("java.util.ListIterator", "kotlin.collections.ListIterator");
+        hashMap3.put("java.util.Map", "kotlin.collections.Map");
+        hashMap3.put("java.util.Map$Entry", "kotlin.collections.Map.Entry");
+        hashMap3.put("kotlin.jvm.internal.StringCompanionObject", "kotlin.String.Companion");
+        hashMap3.put("kotlin.jvm.internal.EnumCompanionObject", "kotlin.Enum.Companion");
+        hashMap3.putAll(hashMap);
+        hashMap3.putAll(hashMap2);
+        Collection<String> values = hashMap.values();
+        Intrinsics.checkNotNullExpressionValue(values, "<get-values>(...)");
+        for (String str : values) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("kotlin.jvm.internal.");
+            Intrinsics.checkNotNull(str);
+            substringAfterLast$default2 = StringsKt__StringsKt.substringAfterLast$default(str, '.', (String) null, 2, (Object) null);
+            sb.append(substringAfterLast$default2);
+            sb.append("CompanionObject");
+            Pair pair = TuplesKt.to(sb.toString(), str + ".Companion");
+            hashMap3.put(pair.getFirst(), pair.getSecond());
+        }
+        for (Map.Entry<Class<? extends Function>, Integer> entry : FUNCTION_CLASSES.entrySet()) {
+            hashMap3.put(entry.getKey().getName(), "kotlin.Function" + entry.getValue().intValue());
+        }
+        classFqNames = hashMap3;
+        mapCapacity = MapsKt__MapsJVMKt.mapCapacity(hashMap3.size());
+        LinkedHashMap linkedHashMap = new LinkedHashMap(mapCapacity);
+        for (Map.Entry entry2 : hashMap3.entrySet()) {
+            Object key = entry2.getKey();
+            substringAfterLast$default = StringsKt__StringsKt.substringAfterLast$default((String) entry2.getValue(), '.', (String) null, 2, (Object) null);
+            linkedHashMap.put(key, substringAfterLast$default);
+        }
+        simpleNames = linkedHashMap;
+    }
+}

decompiled/sources/kotlin/jvm/internal/CollectionToArray.java

@@ -0,0 +1,143 @@
+package kotlin.jvm.internal;
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function2;
+
+@SourceDebugExtension({"SMAP\nCollectionToArray.kt\nKotlin\n*S Kotlin\n*F\n+ 1 CollectionToArray.kt\nkotlin/jvm/internal/CollectionToArray\n+ 2 ArrayIntrinsics.kt\nkotlin/ArrayIntrinsicsKt\n*L\n1#1,88:1\n63#1,22:89\n63#1,22:111\n26#2:133\n*S KotlinDebug\n*F\n+ 1 CollectionToArray.kt\nkotlin/jvm/internal/CollectionToArray\n*L\n22#1:89,22\n37#1:111,22\n14#1:133\n*E\n"})
+/* loaded from: classes5.dex */
+public final class CollectionToArray {
+    private static final Object[] EMPTY = new Object[0];
+    private static final int MAX_SIZE = 2147483645;
+
+    public static final Object[] toArray(Collection<?> collection, Object[] objArr) {
+        Object[] objArr2;
+        Intrinsics.checkNotNullParameter(collection, "collection");
+        objArr.getClass();
+        int size = collection.size();
+        int i = 0;
+        if (size == 0) {
+            if (objArr.length <= 0) {
+                return objArr;
+            }
+            objArr[0] = null;
+            return objArr;
+        }
+        Iterator<?> it = collection.iterator();
+        if (!it.hasNext()) {
+            if (objArr.length <= 0) {
+                return objArr;
+            }
+            objArr[0] = null;
+            return objArr;
+        }
+        if (size <= objArr.length) {
+            objArr2 = objArr;
+        } else {
+            Object newInstance = Array.newInstance(objArr.getClass().getComponentType(), size);
+            Intrinsics.checkNotNull(newInstance, "null cannot be cast to non-null type kotlin.Array<kotlin.Any?>");
+            objArr2 = (Object[]) newInstance;
+        }
+        while (true) {
+            int i2 = i + 1;
+            objArr2[i] = it.next();
+            if (i2 >= objArr2.length) {
+                if (!it.hasNext()) {
+                    return objArr2;
+                }
+                int i3 = ((i2 * 3) + 1) >>> 1;
+                if (i3 <= i2) {
+                    i3 = MAX_SIZE;
+                    if (i2 >= MAX_SIZE) {
+                        throw new OutOfMemoryError();
+                    }
+                }
+                objArr2 = Arrays.copyOf(objArr2, i3);
+                Intrinsics.checkNotNullExpressionValue(objArr2, "copyOf(...)");
+            } else if (!it.hasNext()) {
+                if (objArr2 == objArr) {
+                    objArr[i2] = null;
+                    return objArr;
+                }
+                Object[] copyOf = Arrays.copyOf(objArr2, i2);
+                Intrinsics.checkNotNullExpressionValue(copyOf, "copyOf(...)");
+                return copyOf;
+            }
+            i = i2;
+        }
+    }
+
+    public static final Object[] toArray(Collection<?> collection) {
+        Intrinsics.checkNotNullParameter(collection, "collection");
+        int size = collection.size();
+        if (size != 0) {
+            Iterator<?> it = collection.iterator();
+            if (it.hasNext()) {
+                Object[] objArr = new Object[size];
+                int i = 0;
+                while (true) {
+                    int i2 = i + 1;
+                    objArr[i] = it.next();
+                    if (i2 >= objArr.length) {
+                        if (!it.hasNext()) {
+                            return objArr;
+                        }
+                        int i3 = ((i2 * 3) + 1) >>> 1;
+                        if (i3 <= i2) {
+                            i3 = MAX_SIZE;
+                            if (i2 >= MAX_SIZE) {
+                                throw new OutOfMemoryError();
+                            }
+                        }
+                        objArr = Arrays.copyOf(objArr, i3);
+                        Intrinsics.checkNotNullExpressionValue(objArr, "copyOf(...)");
+                    } else if (!it.hasNext()) {
+                        Object[] copyOf = Arrays.copyOf(objArr, i2);
+                        Intrinsics.checkNotNullExpressionValue(copyOf, "copyOf(...)");
+                        return copyOf;
+                    }
+                    i = i2;
+                }
+            }
+        }
+        return EMPTY;
+    }
+
+    private static final Object[] toArrayImpl(Collection<?> collection, Function0 function0, Function1 function1, Function2 function2) {
+        int size = collection.size();
+        if (size == 0) {
+            return (Object[]) function0.invoke();
+        }
+        Iterator<?> it = collection.iterator();
+        if (!it.hasNext()) {
+            return (Object[]) function0.invoke();
+        }
+        Object[] objArr = (Object[]) function1.invoke(Integer.valueOf(size));
+        int i = 0;
+        while (true) {
+            int i2 = i + 1;
+            objArr[i] = it.next();
+            if (i2 >= objArr.length) {
+                if (!it.hasNext()) {
+                    return objArr;
+                }
+                int i3 = ((i2 * 3) + 1) >>> 1;
+                if (i3 <= i2) {
+                    i3 = MAX_SIZE;
+                    if (i2 >= MAX_SIZE) {
+                        throw new OutOfMemoryError();
+                    }
+                }
+                objArr = Arrays.copyOf(objArr, i3);
+                Intrinsics.checkNotNullExpressionValue(objArr, "copyOf(...)");
+            } else if (!it.hasNext()) {
+                return (Object[]) function2.invoke(objArr, Integer.valueOf(i2));
+            }
+            i = i2;
+        }
+    }
+}

decompiled/sources/kotlin/jvm/internal/DefaultConstructorMarker.java

@@ -0,0 +1,7 @@
+package kotlin.jvm.internal;
+
+/* loaded from: classes5.dex */
+public final class DefaultConstructorMarker {
+    private DefaultConstructorMarker() {
+    }
+}

decompiled/sources/kotlin/jvm/internal/DoubleCompanionObject.java

@@ -0,0 +1,57 @@
+package kotlin.jvm.internal;
+
+/* loaded from: classes5.dex */
+public final class DoubleCompanionObject {
+    public static final DoubleCompanionObject INSTANCE = new DoubleCompanionObject();
+    public static final double MAX_VALUE = Double.MAX_VALUE;
+    public static final double MIN_VALUE = Double.MIN_VALUE;
+    public static final double NEGATIVE_INFINITY = Double.NEGATIVE_INFINITY;
+    public static final double NaN = Double.NaN;
+    public static final double POSITIVE_INFINITY = Double.POSITIVE_INFINITY;
+    public static final int SIZE_BITS = 64;
+    public static final int SIZE_BYTES = 8;
+
+    public static /* synthetic */ void getMAX_VALUE$annotations() {
+    }
+
+    public static /* synthetic */ void getMIN_VALUE$annotations() {
+    }
+
+    public static /* synthetic */ void getNEGATIVE_INFINITY$annotations() {
+    }
+
+    public static /* synthetic */ void getNaN$annotations() {
+    }
+
+    public static /* synthetic */ void getPOSITIVE_INFINITY$annotations() {
+    }
+
+    public static /* synthetic */ void getSIZE_BITS$annotations() {
+    }
+
+    public static /* synthetic */ void getSIZE_BYTES$annotations() {
+    }
+
+    public final double getMAX_VALUE() {
+        return Double.MAX_VALUE;
+    }
+
+    public final double getMIN_VALUE() {
+        return Double.MIN_VALUE;
+    }
+
+    public final double getNEGATIVE_INFINITY() {
+        return Double.NEGATIVE_INFINITY;
+    }
+
+    public final double getNaN() {
+        return Double.NaN;
+    }
+
+    public final double getPOSITIVE_INFINITY() {
+        return Double.POSITIVE_INFINITY;
+    }
+
+    private DoubleCompanionObject() {
+    }
+}

decompiled/sources/kotlin/jvm/internal/DoubleSpreadBuilder.java

@@ -0,0 +1,28 @@
+package kotlin.jvm.internal;
+
+/* loaded from: classes5.dex */
+public final class DoubleSpreadBuilder extends PrimitiveSpreadBuilder<double[]> {
+    private final double[] values;
+
+    public DoubleSpreadBuilder(int i) {
+        super(i);
+        this.values = new double[i];
+    }
+
+    @Override // kotlin.jvm.internal.PrimitiveSpreadBuilder
+    public int getSize(double[] dArr) {
+        Intrinsics.checkNotNullParameter(dArr, "<this>");
+        return dArr.length;
+    }
+
+    public final void add(double d) {
+        double[] dArr = this.values;
+        int position = getPosition();
+        setPosition(position + 1);
+        dArr[position] = d;
+    }
+
+    public final double[] toArray() {
+        return toArray(this.values, new double[size()]);
+    }
+}

decompiled/sources/kotlin/jvm/internal/EnumCompanionObject.java

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

decompiled/sources/kotlin/jvm/internal/FloatCompanionObject.java

@@ -0,0 +1,57 @@
+package kotlin.jvm.internal;
+
+/* loaded from: classes5.dex */
+public final class FloatCompanionObject {
+    public static final FloatCompanionObject INSTANCE = new FloatCompanionObject();
+    public static final float MAX_VALUE = Float.MAX_VALUE;
+    public static final float MIN_VALUE = Float.MIN_VALUE;
+    public static final float NEGATIVE_INFINITY = Float.NEGATIVE_INFINITY;
+    public static final float NaN = Float.NaN;
+    public static final float POSITIVE_INFINITY = Float.POSITIVE_INFINITY;
+    public static final int SIZE_BITS = 32;
+    public static final int SIZE_BYTES = 4;
+
+    public static /* synthetic */ void getMAX_VALUE$annotations() {
+    }
+
+    public static /* synthetic */ void getMIN_VALUE$annotations() {
+    }
+
+    public static /* synthetic */ void getNEGATIVE_INFINITY$annotations() {
+    }
+
+    public static /* synthetic */ void getNaN$annotations() {
+    }
+
+    public static /* synthetic */ void getPOSITIVE_INFINITY$annotations() {
+    }
+
+    public static /* synthetic */ void getSIZE_BITS$annotations() {
+    }
+
+    public static /* synthetic */ void getSIZE_BYTES$annotations() {
+    }
+
+    public final float getMAX_VALUE() {
+        return Float.MAX_VALUE;
+    }
+
+    public final float getMIN_VALUE() {
+        return Float.MIN_VALUE;
+    }
+
+    public final float getNEGATIVE_INFINITY() {
+        return Float.NEGATIVE_INFINITY;
+    }
+
+    public final float getNaN() {
+        return Float.NaN;
+    }
+
+    public final float getPOSITIVE_INFINITY() {
+        return Float.POSITIVE_INFINITY;
+    }
+
+    private FloatCompanionObject() {
+    }
+}

decompiled/sources/kotlin/jvm/internal/FloatSpreadBuilder.java

@@ -0,0 +1,28 @@
+package kotlin.jvm.internal;
+
+/* loaded from: classes5.dex */
+public final class FloatSpreadBuilder extends PrimitiveSpreadBuilder<float[]> {
+    private final float[] values;
+
+    public FloatSpreadBuilder(int i) {
+        super(i);
+        this.values = new float[i];
+    }
+
+    @Override // kotlin.jvm.internal.PrimitiveSpreadBuilder
+    public int getSize(float[] fArr) {
+        Intrinsics.checkNotNullParameter(fArr, "<this>");
+        return fArr.length;
+    }
+
+    public final void add(float f) {
+        float[] fArr = this.values;
+        int position = getPosition();
+        setPosition(position + 1);
+        fArr[position] = f;
+    }
+
+    public final float[] toArray() {
+        return toArray(this.values, new float[size()]);
+    }
+}

decompiled/sources/kotlin/jvm/internal/FunInterfaceConstructorReference.java

@@ -0,0 +1,40 @@
+package kotlin.jvm.internal;
+
+import java.io.Serializable;
+import kotlin.reflect.KFunction;
+
+/* loaded from: classes5.dex */
+public class FunInterfaceConstructorReference extends FunctionReference implements Serializable {
+    private final Class funInterface;
+
+    public FunInterfaceConstructorReference(Class cls) {
+        super(1);
+        this.funInterface = cls;
+    }
+
+    @Override // kotlin.jvm.internal.FunctionReference
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof FunInterfaceConstructorReference) {
+            return this.funInterface.equals(((FunInterfaceConstructorReference) obj).funInterface);
+        }
+        return false;
+    }
+
+    @Override // kotlin.jvm.internal.FunctionReference
+    public int hashCode() {
+        return this.funInterface.hashCode();
+    }
+
+    @Override // kotlin.jvm.internal.FunctionReference
+    public String toString() {
+        return "fun interface " + this.funInterface.getName();
+    }
+
+    @Override // kotlin.jvm.internal.FunctionReference, kotlin.jvm.internal.CallableReference
+    public KFunction getReflected() {
+        throw new UnsupportedOperationException("Functional interface constructor does not support reflection");
+    }
+}

decompiled/sources/kotlin/jvm/internal/FunctionAdapter.java

@@ -0,0 +1,8 @@
+package kotlin.jvm.internal;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface FunctionAdapter {
+    Function getFunctionDelegate();
+}

decompiled/sources/kotlin/jvm/internal/FunctionBase.java

@@ -0,0 +1,8 @@
+package kotlin.jvm.internal;
+
+import kotlin.Function;
+
+/* loaded from: classes5.dex */
+public interface FunctionBase<R> extends Function {
+    int getArity();
+}

decompiled/sources/kotlin/jvm/internal/FunctionImpl.java

@@ -0,0 +1,168 @@
+package kotlin.jvm.internal;
+
+import java.io.Serializable;
+import kotlin.Function;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function10;
+import kotlin.jvm.functions.Function11;
+import kotlin.jvm.functions.Function12;
+import kotlin.jvm.functions.Function13;
+import kotlin.jvm.functions.Function14;
+import kotlin.jvm.functions.Function15;
+import kotlin.jvm.functions.Function16;
+import kotlin.jvm.functions.Function17;
+import kotlin.jvm.functions.Function18;
+import kotlin.jvm.functions.Function19;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.functions.Function20;
+import kotlin.jvm.functions.Function21;
+import kotlin.jvm.functions.Function22;
+import kotlin.jvm.functions.Function3;
+import kotlin.jvm.functions.Function4;
+import kotlin.jvm.functions.Function5;
+import kotlin.jvm.functions.Function6;
+import kotlin.jvm.functions.Function7;
+import kotlin.jvm.functions.Function8;
+import kotlin.jvm.functions.Function9;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public abstract class FunctionImpl implements Function, Serializable, Function0, Function1, Function2, Function3, Function4, Function5, Function6, Function7, Function8, Function9, Function10, Function11, Function12, Function13, Function14, Function15, Function16, Function17, Function18, Function19, Function20, Function21, Function22 {
+    public abstract int getArity();
+
+    public Object invokeVararg(Object... objArr) {
+        throw new UnsupportedOperationException();
+    }
+
+    private void checkArity(int i) {
+        if (getArity() != i) {
+            throwWrongArity(i);
+        }
+    }
+
+    private void throwWrongArity(int i) {
+        throw new IllegalStateException("Wrong function arity, expected: " + i + ", actual: " + getArity());
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public Object invoke() {
+        checkArity(0);
+        return invokeVararg(new Object[0]);
+    }
+
+    @Override // kotlin.jvm.functions.Function1
+    public Object invoke(Object obj) {
+        checkArity(1);
+        return invokeVararg(obj);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public Object invoke(Object obj, Object obj2) {
+        checkArity(2);
+        return invokeVararg(obj, obj2);
+    }
+
+    @Override // kotlin.jvm.functions.Function3
+    public Object invoke(Object obj, Object obj2, Object obj3) {
+        checkArity(3);
+        return invokeVararg(obj, obj2, obj3);
+    }
+
+    @Override // kotlin.jvm.functions.Function4
+    public Object invoke(Object obj, Object obj2, Object obj3, Object obj4) {
+        checkArity(4);
+        return invokeVararg(obj, obj2, obj3, obj4);
+    }
+
+    public Object invoke(Object obj, Object obj2, Object obj3, Object obj4, Object obj5) {
+        checkArity(5);
+        return invokeVararg(obj, obj2, obj3, obj4, obj5);
+    }
+
+    @Override // kotlin.jvm.functions.Function6
+    public Object invoke(Object obj, Object obj2, Object obj3, Object obj4, Object obj5, Object obj6) {
+        checkArity(6);
+        return invokeVararg(obj, obj2, obj3, obj4, obj5, obj6);
+    }
+
+    public Object invoke(Object obj, Object obj2, Object obj3, Object obj4, Object obj5, Object obj6, Object obj7) {
+        checkArity(7);
+        return invokeVararg(obj, obj2, obj3, obj4, obj5, obj6, obj7);
+    }
+
+    public Object invoke(Object obj, Object obj2, Object obj3, Object obj4, Object obj5, Object obj6, Object obj7, Object obj8) {
+        checkArity(8);
+        return invokeVararg(obj, obj2, obj3, obj4, obj5, obj6, obj7, obj8);
+    }
+
+    public Object invoke(Object obj, Object obj2, Object obj3, Object obj4, Object obj5, Object obj6, Object obj7, Object obj8, Object obj9) {
+        checkArity(9);
+        return invokeVararg(obj, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9);
+    }
+
+    public Object invoke(Object obj, Object obj2, Object obj3, Object obj4, Object obj5, Object obj6, Object obj7, Object obj8, Object obj9, Object obj10) {
+        checkArity(10);
+        return invokeVararg(obj, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10);
+    }
+
+    public Object invoke(Object obj, Object obj2, Object obj3, Object obj4, Object obj5, Object obj6, Object obj7, Object obj8, Object obj9, Object obj10, Object obj11) {
+        checkArity(11);
+        return invokeVararg(obj, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11);
+    }
+
+    public Object invoke(Object obj, Object obj2, Object obj3, Object obj4, Object obj5, Object obj6, Object obj7, Object obj8, Object obj9, Object obj10, Object obj11, Object obj12) {
+        checkArity(12);
+        return invokeVararg(obj, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11, obj12);
+    }
+
+    public Object invoke(Object obj, Object obj2, Object obj3, Object obj4, Object obj5, Object obj6, Object obj7, Object obj8, Object obj9, Object obj10, Object obj11, Object obj12, Object obj13) {
+        checkArity(13);
+        return invokeVararg(obj, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11, obj12, obj13);
+    }
+
+    public Object invoke(Object obj, Object obj2, Object obj3, Object obj4, Object obj5, Object obj6, Object obj7, Object obj8, Object obj9, Object obj10, Object obj11, Object obj12, Object obj13, Object obj14) {
+        checkArity(14);
+        return invokeVararg(obj, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11, obj12, obj13, obj14);
+    }
+
+    public Object invoke(Object obj, Object obj2, Object obj3, Object obj4, Object obj5, Object obj6, Object obj7, Object obj8, Object obj9, Object obj10, Object obj11, Object obj12, Object obj13, Object obj14, Object obj15) {
+        checkArity(15);
+        return invokeVararg(obj, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11, obj12, obj13, obj14, obj15);
+    }
+
+    public Object invoke(Object obj, Object obj2, Object obj3, Object obj4, Object obj5, Object obj6, Object obj7, Object obj8, Object obj9, Object obj10, Object obj11, Object obj12, Object obj13, Object obj14, Object obj15, Object obj16) {
+        checkArity(16);
+        return invokeVararg(obj, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11, obj12, obj13, obj14, obj15, obj16);
+    }
+
+    public Object invoke(Object obj, Object obj2, Object obj3, Object obj4, Object obj5, Object obj6, Object obj7, Object obj8, Object obj9, Object obj10, Object obj11, Object obj12, Object obj13, Object obj14, Object obj15, Object obj16, Object obj17) {
+        checkArity(17);
+        return invokeVararg(obj, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11, obj12, obj13, obj14, obj15, obj16, obj17);
+    }
+
+    public Object invoke(Object obj, Object obj2, Object obj3, Object obj4, Object obj5, Object obj6, Object obj7, Object obj8, Object obj9, Object obj10, Object obj11, Object obj12, Object obj13, Object obj14, Object obj15, Object obj16, Object obj17, Object obj18) {
+        checkArity(18);
+        return invokeVararg(obj, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11, obj12, obj13, obj14, obj15, obj16, obj17, obj18);
+    }
+
+    public Object invoke(Object obj, Object obj2, Object obj3, Object obj4, Object obj5, Object obj6, Object obj7, Object obj8, Object obj9, Object obj10, Object obj11, Object obj12, Object obj13, Object obj14, Object obj15, Object obj16, Object obj17, Object obj18, Object obj19) {
+        checkArity(19);
+        return invokeVararg(obj, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11, obj12, obj13, obj14, obj15, obj16, obj17, obj18, obj19);
+    }
+
+    public Object invoke(Object obj, Object obj2, Object obj3, Object obj4, Object obj5, Object obj6, Object obj7, Object obj8, Object obj9, Object obj10, Object obj11, Object obj12, Object obj13, Object obj14, Object obj15, Object obj16, Object obj17, Object obj18, Object obj19, Object obj20) {
+        checkArity(20);
+        return invokeVararg(obj, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11, obj12, obj13, obj14, obj15, obj16, obj17, obj18, obj19, obj20);
+    }
+
+    public Object invoke(Object obj, Object obj2, Object obj3, Object obj4, Object obj5, Object obj6, Object obj7, Object obj8, Object obj9, Object obj10, Object obj11, Object obj12, Object obj13, Object obj14, Object obj15, Object obj16, Object obj17, Object obj18, Object obj19, Object obj20, Object obj21) {
+        checkArity(21);
+        return invokeVararg(obj, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11, obj12, obj13, obj14, obj15, obj16, obj17, obj18, obj19, obj20, obj21);
+    }
+
+    public Object invoke(Object obj, Object obj2, Object obj3, Object obj4, Object obj5, Object obj6, Object obj7, Object obj8, Object obj9, Object obj10, Object obj11, Object obj12, Object obj13, Object obj14, Object obj15, Object obj16, Object obj17, Object obj18, Object obj19, Object obj20, Object obj21, Object obj22) {
+        checkArity(22);
+        return invokeVararg(obj, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11, obj12, obj13, obj14, obj15, obj16, obj17, obj18, obj19, obj20, obj21, obj22);
+    }
+}

decompiled/sources/kotlin/jvm/internal/FunctionReference.java

@@ -0,0 +1,93 @@
+package kotlin.jvm.internal;
+
+import kotlin.reflect.KCallable;
+import kotlin.reflect.KFunction;
+
+/* loaded from: classes5.dex */
+public class FunctionReference extends CallableReference implements FunctionBase, KFunction {
+    private final int arity;
+    private final int flags;
+
+    @Override // kotlin.jvm.internal.FunctionBase
+    public int getArity() {
+        return this.arity;
+    }
+
+    public FunctionReference(int i) {
+        this(i, CallableReference.NO_RECEIVER, null, null, null, 0);
+    }
+
+    public FunctionReference(int i, Object obj) {
+        this(i, obj, null, null, null, 0);
+    }
+
+    public FunctionReference(int i, Object obj, Class cls, String str, String str2, int i2) {
+        super(obj, cls, str, str2, (i2 & 1) == 1);
+        this.arity = i;
+        this.flags = i2 >> 1;
+    }
+
+    @Override // kotlin.jvm.internal.CallableReference
+    public KFunction getReflected() {
+        return (KFunction) super.getReflected();
+    }
+
+    @Override // kotlin.jvm.internal.CallableReference
+    public KCallable computeReflected() {
+        return Reflection.function(this);
+    }
+
+    @Override // kotlin.reflect.KFunction
+    public boolean isInline() {
+        return getReflected().isInline();
+    }
+
+    @Override // kotlin.reflect.KFunction
+    public boolean isExternal() {
+        return getReflected().isExternal();
+    }
+
+    @Override // kotlin.reflect.KFunction
+    public boolean isOperator() {
+        return getReflected().isOperator();
+    }
+
+    @Override // kotlin.reflect.KFunction
+    public boolean isInfix() {
+        return getReflected().isInfix();
+    }
+
+    @Override // kotlin.jvm.internal.CallableReference, kotlin.reflect.KCallable
+    public boolean isSuspend() {
+        return getReflected().isSuspend();
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof FunctionReference) {
+            FunctionReference functionReference = (FunctionReference) obj;
+            return getName().equals(functionReference.getName()) && getSignature().equals(functionReference.getSignature()) && this.flags == functionReference.flags && this.arity == functionReference.arity && Intrinsics.areEqual(getBoundReceiver(), functionReference.getBoundReceiver()) && Intrinsics.areEqual(getOwner(), functionReference.getOwner());
+        }
+        if (obj instanceof KFunction) {
+            return obj.equals(compute());
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return (((getOwner() == null ? 0 : getOwner().hashCode() * 31) + getName().hashCode()) * 31) + getSignature().hashCode();
+    }
+
+    public String toString() {
+        KCallable compute = compute();
+        if (compute != this) {
+            return compute.toString();
+        }
+        if ("<init>".equals(getName())) {
+            return "constructor (Kotlin reflection is not available)";
+        }
+        return "function " + getName() + " (Kotlin reflection is not available)";
+    }
+}

decompiled/sources/kotlin/jvm/internal/FunctionReferenceImpl.java

@@ -0,0 +1,19 @@
+package kotlin.jvm.internal;
+
+import kotlin.reflect.KClass;
+import kotlin.reflect.KDeclarationContainer;
+
+/* loaded from: classes5.dex */
+public class FunctionReferenceImpl extends FunctionReference {
+    public FunctionReferenceImpl(int i, KDeclarationContainer kDeclarationContainer, String str, String str2) {
+        super(i, CallableReference.NO_RECEIVER, ((ClassBasedDeclarationContainer) kDeclarationContainer).getJClass(), str, str2, !(kDeclarationContainer instanceof KClass) ? 1 : 0);
+    }
+
+    public FunctionReferenceImpl(int i, Class cls, String str, String str2, int i2) {
+        super(i, CallableReference.NO_RECEIVER, cls, str, str2, i2);
+    }
+
+    public FunctionReferenceImpl(int i, Object obj, Class cls, String str, String str2, int i2) {
+        super(i, obj, cls, str, str2, i2);
+    }
+}

decompiled/sources/kotlin/jvm/internal/InlineMarker.java

@@ -0,0 +1,22 @@
+package kotlin.jvm.internal;
+
+/* loaded from: classes5.dex */
+public class InlineMarker {
+    public static void afterInlineCall() {
+    }
+
+    public static void beforeInlineCall() {
+    }
+
+    public static void finallyEnd(int i) {
+    }
+
+    public static void finallyStart(int i) {
+    }
+
+    public static void mark(int i) {
+    }
+
+    public static void mark(String str) {
+    }
+}

decompiled/sources/kotlin/jvm/internal/IntCompanionObject.java

@@ -0,0 +1,19 @@
+package kotlin.jvm.internal;
+
+/* loaded from: classes5.dex */
+public final class IntCompanionObject {
+    public static final IntCompanionObject INSTANCE = new IntCompanionObject();
+    public static final int MAX_VALUE = Integer.MAX_VALUE;
+    public static final int MIN_VALUE = Integer.MIN_VALUE;
+    public static final int SIZE_BITS = 32;
+    public static final int SIZE_BYTES = 4;
+
+    public static /* synthetic */ void getSIZE_BITS$annotations() {
+    }
+
+    public static /* synthetic */ void getSIZE_BYTES$annotations() {
+    }
+
+    private IntCompanionObject() {
+    }
+}

decompiled/sources/kotlin/jvm/internal/IntSpreadBuilder.java

@@ -0,0 +1,28 @@
+package kotlin.jvm.internal;
+
+/* loaded from: classes5.dex */
+public final class IntSpreadBuilder extends PrimitiveSpreadBuilder<int[]> {
+    private final int[] values;
+
+    public IntSpreadBuilder(int i) {
+        super(i);
+        this.values = new int[i];
+    }
+
+    @Override // kotlin.jvm.internal.PrimitiveSpreadBuilder
+    public int getSize(int[] iArr) {
+        Intrinsics.checkNotNullParameter(iArr, "<this>");
+        return iArr.length;
+    }
+
+    public final void add(int i) {
+        int[] iArr = this.values;
+        int position = getPosition();
+        setPosition(position + 1);
+        iArr[position] = i;
+    }
+
+    public final int[] toArray() {
+        return toArray(this.values, new int[size()]);
+    }
+}

decompiled/sources/kotlin/jvm/internal/Intrinsics.java

@@ -0,0 +1,273 @@
+package kotlin.jvm.internal;
+
+import csdk.gluads.Consts;
+import java.util.Arrays;
+import kotlin.KotlinNullPointerException;
+import kotlin.UninitializedPropertyAccessException;
+
+/* loaded from: classes5.dex */
+public class Intrinsics {
+    public static int compare(int i, int i2) {
+        if (i < i2) {
+            return -1;
+        }
+        return i == i2 ? 0 : 1;
+    }
+
+    public static int compare(long j, long j2) {
+        if (j < j2) {
+            return -1;
+        }
+        return j == j2 ? 0 : 1;
+    }
+
+    private Intrinsics() {
+    }
+
+    public static String stringPlus(String str, Object obj) {
+        return str + obj;
+    }
+
+    public static void checkNotNull(Object obj) {
+        if (obj == null) {
+            throwJavaNpe();
+        }
+    }
+
+    public static void checkNotNull(Object obj, String str) {
+        if (obj == null) {
+            throwJavaNpe(str);
+        }
+    }
+
+    public static void throwNpe() {
+        throw ((KotlinNullPointerException) sanitizeStackTrace(new KotlinNullPointerException()));
+    }
+
+    public static void throwNpe(String str) {
+        throw ((KotlinNullPointerException) sanitizeStackTrace(new KotlinNullPointerException(str)));
+    }
+
+    public static void throwJavaNpe() {
+        throw ((NullPointerException) sanitizeStackTrace(new NullPointerException()));
+    }
+
+    public static void throwJavaNpe(String str) {
+        throw ((NullPointerException) sanitizeStackTrace(new NullPointerException(str)));
+    }
+
+    public static void throwUninitializedProperty(String str) {
+        throw ((UninitializedPropertyAccessException) sanitizeStackTrace(new UninitializedPropertyAccessException(str)));
+    }
+
+    public static void throwUninitializedPropertyAccessException(String str) {
+        throwUninitializedProperty("lateinit property " + str + " has not been initialized");
+    }
+
+    public static void throwAssert() {
+        throw ((AssertionError) sanitizeStackTrace(new AssertionError()));
+    }
+
+    public static void throwAssert(String str) {
+        throw ((AssertionError) sanitizeStackTrace(new AssertionError(str)));
+    }
+
+    public static void throwIllegalArgument() {
+        throw ((IllegalArgumentException) sanitizeStackTrace(new IllegalArgumentException()));
+    }
+
+    public static void throwIllegalArgument(String str) {
+        throw ((IllegalArgumentException) sanitizeStackTrace(new IllegalArgumentException(str)));
+    }
+
+    public static void throwIllegalState() {
+        throw ((IllegalStateException) sanitizeStackTrace(new IllegalStateException()));
+    }
+
+    public static void throwIllegalState(String str) {
+        throw ((IllegalStateException) sanitizeStackTrace(new IllegalStateException(str)));
+    }
+
+    public static void checkExpressionValueIsNotNull(Object obj, String str) {
+        if (obj != null) {
+            return;
+        }
+        throw ((IllegalStateException) sanitizeStackTrace(new IllegalStateException(str + " must not be null")));
+    }
+
+    public static void checkNotNullExpressionValue(Object obj, String str) {
+        if (obj != null) {
+            return;
+        }
+        throw ((NullPointerException) sanitizeStackTrace(new NullPointerException(str + " must not be null")));
+    }
+
+    public static void checkReturnedValueIsNotNull(Object obj, String str, String str2) {
+        if (obj != null) {
+            return;
+        }
+        throw ((IllegalStateException) sanitizeStackTrace(new IllegalStateException("Method specified as non-null returned null: " + str + Consts.STRING_PERIOD + str2)));
+    }
+
+    public static void checkReturnedValueIsNotNull(Object obj, String str) {
+        if (obj == null) {
+            throw ((IllegalStateException) sanitizeStackTrace(new IllegalStateException(str)));
+        }
+    }
+
+    public static void checkFieldIsNotNull(Object obj, String str, String str2) {
+        if (obj != null) {
+            return;
+        }
+        throw ((IllegalStateException) sanitizeStackTrace(new IllegalStateException("Field specified as non-null is null: " + str + Consts.STRING_PERIOD + str2)));
+    }
+
+    public static void checkFieldIsNotNull(Object obj, String str) {
+        if (obj == null) {
+            throw ((IllegalStateException) sanitizeStackTrace(new IllegalStateException(str)));
+        }
+    }
+
+    public static void checkParameterIsNotNull(Object obj, String str) {
+        if (obj == null) {
+            throwParameterIsNullIAE(str);
+        }
+    }
+
+    public static void checkNotNullParameter(Object obj, String str) {
+        if (obj == null) {
+            throwParameterIsNullNPE(str);
+        }
+    }
+
+    private static void throwParameterIsNullIAE(String str) {
+        throw ((IllegalArgumentException) sanitizeStackTrace(new IllegalArgumentException(createParameterIsNullExceptionMessage(str))));
+    }
+
+    private static void throwParameterIsNullNPE(String str) {
+        throw ((NullPointerException) sanitizeStackTrace(new NullPointerException(createParameterIsNullExceptionMessage(str))));
+    }
+
+    private static String createParameterIsNullExceptionMessage(String str) {
+        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
+        String name = Intrinsics.class.getName();
+        int i = 0;
+        while (!stackTrace[i].getClassName().equals(name)) {
+            i++;
+        }
+        while (stackTrace[i].getClassName().equals(name)) {
+            i++;
+        }
+        StackTraceElement stackTraceElement = stackTrace[i];
+        return "Parameter specified as non-null is null: method " + stackTraceElement.getClassName() + Consts.STRING_PERIOD + stackTraceElement.getMethodName() + ", parameter " + str;
+    }
+
+    public static boolean areEqual(Object obj, Object obj2) {
+        if (obj == null) {
+            return obj2 == null;
+        }
+        return obj.equals(obj2);
+    }
+
+    public static boolean areEqual(Double d, Double d2) {
+        if (d == null) {
+            if (d2 != null) {
+                return false;
+            }
+        } else if (d2 == null || d.doubleValue() != d2.doubleValue()) {
+            return false;
+        }
+        return true;
+    }
+
+    public static boolean areEqual(Double d, double d2) {
+        return d != null && d.doubleValue() == d2;
+    }
+
+    public static boolean areEqual(double d, Double d2) {
+        return d2 != null && d == d2.doubleValue();
+    }
+
+    public static boolean areEqual(Float f, Float f2) {
+        if (f == null) {
+            if (f2 != null) {
+                return false;
+            }
+        } else if (f2 == null || f.floatValue() != f2.floatValue()) {
+            return false;
+        }
+        return true;
+    }
+
+    public static boolean areEqual(Float f, float f2) {
+        return f != null && f.floatValue() == f2;
+    }
+
+    public static boolean areEqual(float f, Float f2) {
+        return f2 != null && f == f2.floatValue();
+    }
+
+    public static void throwUndefinedForReified() {
+        throwUndefinedForReified("This function has a reified type parameter and thus can only be inlined at compilation time, not called directly.");
+    }
+
+    public static void throwUndefinedForReified(String str) {
+        throw new UnsupportedOperationException(str);
+    }
+
+    public static void reifiedOperationMarker(int i, String str) {
+        throwUndefinedForReified();
+    }
+
+    public static void reifiedOperationMarker(int i, String str, String str2) {
+        throwUndefinedForReified(str2);
+    }
+
+    public static void needClassReification() {
+        throwUndefinedForReified();
+    }
+
+    public static void needClassReification(String str) {
+        throwUndefinedForReified(str);
+    }
+
+    public static void checkHasClass(String str) throws ClassNotFoundException {
+        String replace = str.replace('/', '.');
+        try {
+            Class.forName(replace);
+        } catch (ClassNotFoundException e) {
+            throw ((ClassNotFoundException) sanitizeStackTrace(new ClassNotFoundException("Class " + replace + " is not found. Please update the Kotlin runtime to the latest version", e)));
+        }
+    }
+
+    public static void checkHasClass(String str, String str2) throws ClassNotFoundException {
+        String replace = str.replace('/', '.');
+        try {
+            Class.forName(replace);
+        } catch (ClassNotFoundException e) {
+            throw ((ClassNotFoundException) sanitizeStackTrace(new ClassNotFoundException("Class " + replace + " is not found: this code requires the Kotlin runtime of version at least " + str2, e)));
+        }
+    }
+
+    private static <T extends Throwable> T sanitizeStackTrace(T t) {
+        return (T) sanitizeStackTrace(t, Intrinsics.class.getName());
+    }
+
+    public static <T extends Throwable> T sanitizeStackTrace(T t, String str) {
+        StackTraceElement[] stackTrace = t.getStackTrace();
+        int length = stackTrace.length;
+        int i = -1;
+        for (int i2 = 0; i2 < length; i2++) {
+            if (str.equals(stackTrace[i2].getClassName())) {
+                i = i2;
+            }
+        }
+        t.setStackTrace((StackTraceElement[]) Arrays.copyOfRange(stackTrace, i + 1, length));
+        return t;
+    }
+
+    public static class Kotlin {
+        private Kotlin() {
+        }
+    }
+}

decompiled/sources/kotlin/jvm/internal/KTypeBase.java

@@ -0,0 +1,22 @@
+package kotlin.jvm.internal;
+
+import java.lang.reflect.Type;
+import java.util.List;
+import kotlin.reflect.KClassifier;
+import kotlin.reflect.KType;
+
+/* loaded from: classes5.dex */
+public interface KTypeBase extends KType {
+    @Override // kotlin.reflect.KAnnotatedElement
+    /* synthetic */ List getAnnotations();
+
+    @Override // kotlin.reflect.KType
+    /* synthetic */ List getArguments();
+
+    @Override // kotlin.reflect.KType
+    /* synthetic */ KClassifier getClassifier();
+
+    Type getJavaType();
+
+    /* synthetic */ boolean isMarkedNullable();
+}

decompiled/sources/kotlin/jvm/internal/Lambda.java

@@ -0,0 +1,23 @@
+package kotlin.jvm.internal;
+
+import java.io.Serializable;
+
+/* loaded from: classes5.dex */
+public abstract class Lambda<R> implements FunctionBase<R>, Serializable {
+    private final int arity;
+
+    @Override // kotlin.jvm.internal.FunctionBase
+    public int getArity() {
+        return this.arity;
+    }
+
+    public Lambda(int i) {
+        this.arity = i;
+    }
+
+    public String toString() {
+        String renderLambdaToString = Reflection.renderLambdaToString((Lambda) this);
+        Intrinsics.checkNotNullExpressionValue(renderLambdaToString, "renderLambdaToString(...)");
+        return renderLambdaToString;
+    }
+}

decompiled/sources/kotlin/jvm/internal/LocalVariableReference.java

@@ -0,0 +1,19 @@
+package kotlin.jvm.internal;
+
+import kotlin.KotlinNothingValueException;
+import kotlin.reflect.KDeclarationContainer;
+
+/* loaded from: classes5.dex */
+public class LocalVariableReference extends PropertyReference0 {
+    @Override // kotlin.jvm.internal.CallableReference
+    public KDeclarationContainer getOwner() {
+        LocalVariableReferencesKt.notSupportedError();
+        throw new KotlinNothingValueException();
+    }
+
+    @Override // kotlin.jvm.internal.PropertyReference0
+    public Object get() {
+        LocalVariableReferencesKt.notSupportedError();
+        throw new KotlinNothingValueException();
+    }
+}

decompiled/sources/kotlin/jvm/internal/LocalVariableReferencesKt.java

@@ -0,0 +1,9 @@
+package kotlin.jvm.internal;
+
+/* loaded from: classes5.dex */
+public final class LocalVariableReferencesKt {
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final Void notSupportedError() {
+        throw new UnsupportedOperationException("Not supported for local property reference.");
+    }
+}

decompiled/sources/kotlin/jvm/internal/LongCompanionObject.java

@@ -0,0 +1,19 @@
+package kotlin.jvm.internal;
+
+/* loaded from: classes5.dex */
+public final class LongCompanionObject {
+    public static final LongCompanionObject INSTANCE = new LongCompanionObject();
+    public static final long MAX_VALUE = Long.MAX_VALUE;
+    public static final long MIN_VALUE = Long.MIN_VALUE;
+    public static final int SIZE_BITS = 64;
+    public static final int SIZE_BYTES = 8;
+
+    public static /* synthetic */ void getSIZE_BITS$annotations() {
+    }
+
+    public static /* synthetic */ void getSIZE_BYTES$annotations() {
+    }
+
+    private LongCompanionObject() {
+    }
+}

decompiled/sources/kotlin/jvm/internal/LongSpreadBuilder.java

@@ -0,0 +1,28 @@
+package kotlin.jvm.internal;
+
+/* loaded from: classes5.dex */
+public final class LongSpreadBuilder extends PrimitiveSpreadBuilder<long[]> {
+    private final long[] values;
+
+    public LongSpreadBuilder(int i) {
+        super(i);
+        this.values = new long[i];
+    }
+
+    @Override // kotlin.jvm.internal.PrimitiveSpreadBuilder
+    public int getSize(long[] jArr) {
+        Intrinsics.checkNotNullParameter(jArr, "<this>");
+        return jArr.length;
+    }
+
+    public final void add(long j) {
+        long[] jArr = this.values;
+        int position = getPosition();
+        setPosition(position + 1);
+        jArr[position] = j;
+    }
+
+    public final long[] toArray() {
+        return toArray(this.values, new long[size()]);
+    }
+}

decompiled/sources/kotlin/jvm/internal/MagicApiIntrinsics.java

@@ -0,0 +1,58 @@
+package kotlin.jvm.internal;
+
+/* loaded from: classes5.dex */
+public class MagicApiIntrinsics {
+    public static <T> T anyMagicApiCall(int i) {
+        return null;
+    }
+
+    public static <T> T anyMagicApiCall(int i, long j, long j2, Object obj) {
+        return null;
+    }
+
+    public static <T> T anyMagicApiCall(int i, long j, Object obj) {
+        return null;
+    }
+
+    public static <T> T anyMagicApiCall(int i, Object obj, Object obj2) {
+        return null;
+    }
+
+    public static <T> T anyMagicApiCall(int i, Object obj, Object obj2, Object obj3, Object obj4) {
+        return null;
+    }
+
+    public static <T> T anyMagicApiCall(Object obj) {
+        return null;
+    }
+
+    public static int intMagicApiCall(int i) {
+        return 0;
+    }
+
+    public static int intMagicApiCall(int i, long j, long j2, Object obj) {
+        return 0;
+    }
+
+    public static int intMagicApiCall(int i, long j, Object obj) {
+        return 0;
+    }
+
+    public static int intMagicApiCall(int i, Object obj, Object obj2) {
+        return 0;
+    }
+
+    public static int intMagicApiCall(int i, Object obj, Object obj2, Object obj3, Object obj4) {
+        return 0;
+    }
+
+    public static int intMagicApiCall(Object obj) {
+        return 0;
+    }
+
+    public static void voidMagicApiCall(int i) {
+    }
+
+    public static void voidMagicApiCall(Object obj) {
+    }
+}

decompiled/sources/kotlin/jvm/internal/MutableLocalVariableReference.java

@@ -0,0 +1,25 @@
+package kotlin.jvm.internal;
+
+import kotlin.KotlinNothingValueException;
+import kotlin.reflect.KDeclarationContainer;
+
+/* loaded from: classes5.dex */
+public class MutableLocalVariableReference extends MutablePropertyReference0 {
+    @Override // kotlin.jvm.internal.CallableReference
+    public KDeclarationContainer getOwner() {
+        LocalVariableReferencesKt.notSupportedError();
+        throw new KotlinNothingValueException();
+    }
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference0
+    public Object get() {
+        LocalVariableReferencesKt.notSupportedError();
+        throw new KotlinNothingValueException();
+    }
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference0, kotlin.reflect.KMutableProperty0
+    public void set(Object obj) {
+        LocalVariableReferencesKt.notSupportedError();
+        throw new KotlinNothingValueException();
+    }
+}

decompiled/sources/kotlin/jvm/internal/MutablePropertyReference.java

@@ -0,0 +1,23 @@
+package kotlin.jvm.internal;
+
+import kotlin.reflect.KMutableProperty$Setter;
+import kotlin.reflect.KProperty;
+
+/* loaded from: classes5.dex */
+public abstract class MutablePropertyReference extends PropertyReference implements KProperty {
+    @Override // kotlin.jvm.internal.PropertyReference
+    public abstract /* synthetic */ KProperty.Getter getGetter();
+
+    public abstract /* synthetic */ KMutableProperty$Setter getSetter();
+
+    public MutablePropertyReference() {
+    }
+
+    public MutablePropertyReference(Object obj) {
+        super(obj);
+    }
+
+    public MutablePropertyReference(Object obj, Class cls, String str, String str2, int i) {
+        super(obj, cls, str, str2, i);
+    }
+}

decompiled/sources/kotlin/jvm/internal/MutablePropertyReference0.java

@@ -0,0 +1,64 @@
+package kotlin.jvm.internal;
+
+import kotlin.reflect.KCallable;
+import kotlin.reflect.KMutableProperty$Setter;
+import kotlin.reflect.KMutableProperty0;
+import kotlin.reflect.KProperty;
+import kotlin.reflect.KProperty0;
+
+/* loaded from: classes5.dex */
+public abstract class MutablePropertyReference0 extends MutablePropertyReference implements KMutableProperty0 {
+    public abstract /* synthetic */ Object get();
+
+    public abstract /* synthetic */ void set(Object obj);
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference, kotlin.jvm.internal.PropertyReference
+    public /* bridge */ /* synthetic */ KProperty.Getter getGetter() {
+        getGetter();
+        return null;
+    }
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference
+    public /* bridge */ /* synthetic */ KMutableProperty$Setter getSetter() {
+        getSetter();
+        return null;
+    }
+
+    public MutablePropertyReference0() {
+    }
+
+    public MutablePropertyReference0(Object obj) {
+        super(obj);
+    }
+
+    public MutablePropertyReference0(Object obj, Class cls, String str, String str2, int i) {
+        super(obj, cls, str, str2, i);
+    }
+
+    @Override // kotlin.jvm.internal.CallableReference
+    public KCallable computeReflected() {
+        return Reflection.mutableProperty0(this);
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public Object invoke() {
+        return get();
+    }
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference, kotlin.jvm.internal.PropertyReference
+    public KProperty0.Getter getGetter() {
+        ((KMutableProperty0) getReflected()).getGetter();
+        return null;
+    }
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference
+    public KMutableProperty0.Setter getSetter() {
+        ((KMutableProperty0) getReflected()).getSetter();
+        return null;
+    }
+
+    @Override // kotlin.reflect.KProperty0
+    public Object getDelegate() {
+        return ((KMutableProperty0) getReflected()).getDelegate();
+    }
+}

decompiled/sources/kotlin/jvm/internal/MutablePropertyReference0Impl.java

@@ -0,0 +1,31 @@
+package kotlin.jvm.internal;
+
+import kotlin.reflect.KClass;
+import kotlin.reflect.KDeclarationContainer;
+
+/* loaded from: classes5.dex */
+public class MutablePropertyReference0Impl extends MutablePropertyReference0 {
+    public MutablePropertyReference0Impl(KDeclarationContainer kDeclarationContainer, String str, String str2) {
+        super(CallableReference.NO_RECEIVER, ((ClassBasedDeclarationContainer) kDeclarationContainer).getJClass(), str, str2, !(kDeclarationContainer instanceof KClass) ? 1 : 0);
+    }
+
+    public MutablePropertyReference0Impl(Class cls, String str, String str2, int i) {
+        super(CallableReference.NO_RECEIVER, cls, str, str2, i);
+    }
+
+    public MutablePropertyReference0Impl(Object obj, Class cls, String str, String str2, int i) {
+        super(obj, cls, str, str2, i);
+    }
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference0
+    public Object get() {
+        getGetter();
+        throw null;
+    }
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference0, kotlin.reflect.KMutableProperty0
+    public void set(Object obj) {
+        getSetter();
+        throw null;
+    }
+}

decompiled/sources/kotlin/jvm/internal/MutablePropertyReference1.java

@@ -0,0 +1,64 @@
+package kotlin.jvm.internal;
+
+import kotlin.reflect.KCallable;
+import kotlin.reflect.KMutableProperty$Setter;
+import kotlin.reflect.KMutableProperty1;
+import kotlin.reflect.KProperty;
+import kotlin.reflect.KProperty1;
+
+/* loaded from: classes5.dex */
+public abstract class MutablePropertyReference1 extends MutablePropertyReference implements KMutableProperty1 {
+    public abstract /* synthetic */ Object get(Object obj);
+
+    public abstract /* synthetic */ void set(Object obj, Object obj2);
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference, kotlin.jvm.internal.PropertyReference
+    public /* bridge */ /* synthetic */ KProperty.Getter getGetter() {
+        getGetter();
+        return null;
+    }
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference
+    public /* bridge */ /* synthetic */ KMutableProperty$Setter getSetter() {
+        getSetter();
+        return null;
+    }
+
+    public MutablePropertyReference1() {
+    }
+
+    public MutablePropertyReference1(Object obj) {
+        super(obj);
+    }
+
+    public MutablePropertyReference1(Object obj, Class cls, String str, String str2, int i) {
+        super(obj, cls, str, str2, i);
+    }
+
+    @Override // kotlin.jvm.internal.CallableReference
+    public KCallable computeReflected() {
+        return Reflection.mutableProperty1(this);
+    }
+
+    @Override // kotlin.jvm.functions.Function1
+    public Object invoke(Object obj) {
+        return get(obj);
+    }
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference, kotlin.jvm.internal.PropertyReference
+    public KProperty1.Getter getGetter() {
+        ((KMutableProperty1) getReflected()).getGetter();
+        return null;
+    }
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference
+    public KMutableProperty1.Setter getSetter() {
+        ((KMutableProperty1) getReflected()).getSetter();
+        return null;
+    }
+
+    @Override // kotlin.reflect.KProperty1
+    public Object getDelegate(Object obj) {
+        return ((KMutableProperty1) getReflected()).getDelegate(obj);
+    }
+}

decompiled/sources/kotlin/jvm/internal/MutablePropertyReference1Impl.java

@@ -0,0 +1,31 @@
+package kotlin.jvm.internal;
+
+import kotlin.reflect.KClass;
+import kotlin.reflect.KDeclarationContainer;
+
+/* loaded from: classes5.dex */
+public class MutablePropertyReference1Impl extends MutablePropertyReference1 {
+    public MutablePropertyReference1Impl(KDeclarationContainer kDeclarationContainer, String str, String str2) {
+        super(CallableReference.NO_RECEIVER, ((ClassBasedDeclarationContainer) kDeclarationContainer).getJClass(), str, str2, !(kDeclarationContainer instanceof KClass) ? 1 : 0);
+    }
+
+    public MutablePropertyReference1Impl(Class cls, String str, String str2, int i) {
+        super(CallableReference.NO_RECEIVER, cls, str, str2, i);
+    }
+
+    public MutablePropertyReference1Impl(Object obj, Class cls, String str, String str2, int i) {
+        super(obj, cls, str, str2, i);
+    }
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference1
+    public Object get(Object obj) {
+        getGetter();
+        throw null;
+    }
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference1
+    public void set(Object obj, Object obj2) {
+        getSetter();
+        throw null;
+    }
+}

decompiled/sources/kotlin/jvm/internal/MutablePropertyReference2.java

@@ -0,0 +1,60 @@
+package kotlin.jvm.internal;
+
+import kotlin.reflect.KCallable;
+import kotlin.reflect.KMutableProperty$Setter;
+import kotlin.reflect.KMutableProperty2;
+import kotlin.reflect.KProperty;
+import kotlin.reflect.KProperty2;
+
+/* loaded from: classes5.dex */
+public abstract class MutablePropertyReference2 extends MutablePropertyReference implements KMutableProperty2 {
+    public abstract /* synthetic */ Object get(Object obj, Object obj2);
+
+    public abstract /* synthetic */ void set(Object obj, Object obj2, Object obj3);
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference, kotlin.jvm.internal.PropertyReference
+    public /* bridge */ /* synthetic */ KProperty.Getter getGetter() {
+        getGetter();
+        return null;
+    }
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference
+    public /* bridge */ /* synthetic */ KMutableProperty$Setter getSetter() {
+        getSetter();
+        return null;
+    }
+
+    public MutablePropertyReference2() {
+    }
+
+    public MutablePropertyReference2(Class cls, String str, String str2, int i) {
+        super(CallableReference.NO_RECEIVER, cls, str, str2, i);
+    }
+
+    @Override // kotlin.jvm.internal.CallableReference
+    public KCallable computeReflected() {
+        return Reflection.mutableProperty2(this);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public Object invoke(Object obj, Object obj2) {
+        return get(obj, obj2);
+    }
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference, kotlin.jvm.internal.PropertyReference
+    public KProperty2.Getter getGetter() {
+        ((KMutableProperty2) getReflected()).getGetter();
+        return null;
+    }
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference
+    public KMutableProperty2.Setter getSetter() {
+        ((KMutableProperty2) getReflected()).getSetter();
+        return null;
+    }
+
+    @Override // kotlin.reflect.KProperty2
+    public Object getDelegate(Object obj, Object obj2) {
+        return ((KMutableProperty2) getReflected()).getDelegate(obj, obj2);
+    }
+}

decompiled/sources/kotlin/jvm/internal/MutablePropertyReference2Impl.java

@@ -0,0 +1,27 @@
+package kotlin.jvm.internal;
+
+import kotlin.reflect.KClass;
+import kotlin.reflect.KDeclarationContainer;
+
+/* loaded from: classes5.dex */
+public class MutablePropertyReference2Impl extends MutablePropertyReference2 {
+    public MutablePropertyReference2Impl(KDeclarationContainer kDeclarationContainer, String str, String str2) {
+        super(((ClassBasedDeclarationContainer) kDeclarationContainer).getJClass(), str, str2, !(kDeclarationContainer instanceof KClass) ? 1 : 0);
+    }
+
+    public MutablePropertyReference2Impl(Class cls, String str, String str2, int i) {
+        super(cls, str, str2, i);
+    }
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference2
+    public Object get(Object obj, Object obj2) {
+        getGetter();
+        throw null;
+    }
+
+    @Override // kotlin.jvm.internal.MutablePropertyReference2
+    public void set(Object obj, Object obj2, Object obj3) {
+        getSetter();
+        throw null;
+    }
+}

decompiled/sources/kotlin/jvm/internal/PackageReference.java

@@ -0,0 +1,40 @@
+package kotlin.jvm.internal;
+
+import java.util.Collection;
+import kotlin.jvm.KotlinReflectionNotSupportedError;
+import kotlin.reflect.KCallable;
+
+/* loaded from: classes5.dex */
+public final class PackageReference implements ClassBasedDeclarationContainer {
+    private final Class<?> jClass;
+    private final String moduleName;
+
+    @Override // kotlin.jvm.internal.ClassBasedDeclarationContainer
+    public Class<?> getJClass() {
+        return this.jClass;
+    }
+
+    public PackageReference(Class<?> jClass, String moduleName) {
+        Intrinsics.checkNotNullParameter(jClass, "jClass");
+        Intrinsics.checkNotNullParameter(moduleName, "moduleName");
+        this.jClass = jClass;
+        this.moduleName = moduleName;
+    }
+
+    @Override // kotlin.jvm.internal.ClassBasedDeclarationContainer
+    public Collection<KCallable> getMembers() {
+        throw new KotlinReflectionNotSupportedError();
+    }
+
+    public boolean equals(Object obj) {
+        return (obj instanceof PackageReference) && Intrinsics.areEqual(getJClass(), ((PackageReference) obj).getJClass());
+    }
+
+    public int hashCode() {
+        return getJClass().hashCode();
+    }
+
+    public String toString() {
+        return getJClass().toString() + " (Kotlin reflection is not available)";
+    }
+}

decompiled/sources/kotlin/jvm/internal/PrimitiveSpreadBuilder.java

@@ -0,0 +1,75 @@
+package kotlin.jvm.internal;
+
+import kotlin.collections.IntIterator;
+import kotlin.ranges.IntRange;
+
+/* loaded from: classes5.dex */
+public abstract class PrimitiveSpreadBuilder<T> {
+    private int position;
+    private final int size;
+    private final T[] spreads;
+
+    private static /* synthetic */ void getSpreads$annotations() {
+    }
+
+    public final int getPosition() {
+        return this.position;
+    }
+
+    public abstract int getSize(T t);
+
+    public final void setPosition(int i) {
+        this.position = i;
+    }
+
+    public PrimitiveSpreadBuilder(int i) {
+        this.size = i;
+        this.spreads = (T[]) new Object[i];
+    }
+
+    public final void addSpread(T spreadArgument) {
+        Intrinsics.checkNotNullParameter(spreadArgument, "spreadArgument");
+        T[] tArr = this.spreads;
+        int i = this.position;
+        this.position = i + 1;
+        tArr[i] = spreadArgument;
+    }
+
+    public final int size() {
+        int i = 0;
+        IntIterator it = new IntRange(0, this.size - 1).iterator();
+        while (it.hasNext()) {
+            T t = this.spreads[it.nextInt()];
+            i += t != null ? getSize(t) : 1;
+        }
+        return i;
+    }
+
+    public final T toArray(T values, T result) {
+        Intrinsics.checkNotNullParameter(values, "values");
+        Intrinsics.checkNotNullParameter(result, "result");
+        IntIterator it = new IntRange(0, this.size - 1).iterator();
+        int i = 0;
+        int i2 = 0;
+        while (it.hasNext()) {
+            int nextInt = it.nextInt();
+            T t = this.spreads[nextInt];
+            if (t != null) {
+                if (i < nextInt) {
+                    int i3 = nextInt - i;
+                    System.arraycopy(values, i, result, i2, i3);
+                    i2 += i3;
+                }
+                int size = getSize(t);
+                System.arraycopy(t, 0, result, i2, size);
+                i2 += size;
+                i = nextInt + 1;
+            }
+        }
+        int i4 = this.size;
+        if (i < i4) {
+            System.arraycopy(values, i, result, i2, i4 - i);
+        }
+        return result;
+    }
+}

decompiled/sources/kotlin/jvm/internal/PropertyReference.java

@@ -0,0 +1,74 @@
+package kotlin.jvm.internal;
+
+import kotlin.reflect.KCallable;
+import kotlin.reflect.KProperty;
+
+/* loaded from: classes5.dex */
+public abstract class PropertyReference extends CallableReference implements KProperty {
+    private final boolean syntheticJavaProperty;
+
+    public abstract /* synthetic */ KProperty.Getter getGetter();
+
+    public PropertyReference() {
+        this.syntheticJavaProperty = false;
+    }
+
+    public PropertyReference(Object obj) {
+        super(obj);
+        this.syntheticJavaProperty = false;
+    }
+
+    public PropertyReference(Object obj, Class cls, String str, String str2, int i) {
+        super(obj, cls, str, str2, (i & 1) == 1);
+        this.syntheticJavaProperty = (i & 2) == 2;
+    }
+
+    @Override // kotlin.jvm.internal.CallableReference
+    public KProperty getReflected() {
+        if (this.syntheticJavaProperty) {
+            throw new UnsupportedOperationException("Kotlin reflection is not yet supported for synthetic Java properties");
+        }
+        return (KProperty) super.getReflected();
+    }
+
+    @Override // kotlin.jvm.internal.CallableReference
+    public KCallable compute() {
+        return this.syntheticJavaProperty ? this : super.compute();
+    }
+
+    @Override // kotlin.reflect.KProperty
+    public boolean isLateinit() {
+        return getReflected().isLateinit();
+    }
+
+    @Override // kotlin.reflect.KProperty
+    public boolean isConst() {
+        return getReflected().isConst();
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof PropertyReference) {
+            PropertyReference propertyReference = (PropertyReference) obj;
+            return getOwner().equals(propertyReference.getOwner()) && getName().equals(propertyReference.getName()) && getSignature().equals(propertyReference.getSignature()) && Intrinsics.areEqual(getBoundReceiver(), propertyReference.getBoundReceiver());
+        }
+        if (obj instanceof KProperty) {
+            return obj.equals(compute());
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return (((getOwner().hashCode() * 31) + getName().hashCode()) * 31) + getSignature().hashCode();
+    }
+
+    public String toString() {
+        KCallable compute = compute();
+        if (compute != this) {
+            return compute.toString();
+        }
+        return "property " + getName() + " (Kotlin reflection is not available)";
+    }
+}

decompiled/sources/kotlin/jvm/internal/PropertyReference0.java

@@ -0,0 +1,48 @@
+package kotlin.jvm.internal;
+
+import kotlin.reflect.KCallable;
+import kotlin.reflect.KProperty;
+import kotlin.reflect.KProperty0;
+
+/* loaded from: classes5.dex */
+public abstract class PropertyReference0 extends PropertyReference implements KProperty0 {
+    public abstract /* synthetic */ Object get();
+
+    @Override // kotlin.jvm.internal.PropertyReference
+    public /* bridge */ /* synthetic */ KProperty.Getter getGetter() {
+        getGetter();
+        return null;
+    }
+
+    public PropertyReference0() {
+    }
+
+    public PropertyReference0(Object obj) {
+        super(obj);
+    }
+
+    public PropertyReference0(Object obj, Class cls, String str, String str2, int i) {
+        super(obj, cls, str, str2, i);
+    }
+
+    @Override // kotlin.jvm.internal.CallableReference
+    public KCallable computeReflected() {
+        return Reflection.property0(this);
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public Object invoke() {
+        return get();
+    }
+
+    @Override // kotlin.jvm.internal.PropertyReference
+    public KProperty0.Getter getGetter() {
+        ((KProperty0) getReflected()).getGetter();
+        return null;
+    }
+
+    @Override // kotlin.reflect.KProperty0
+    public Object getDelegate() {
+        return ((KProperty0) getReflected()).getDelegate();
+    }
+}

decompiled/sources/kotlin/jvm/internal/PropertyReference0Impl.java

@@ -0,0 +1,25 @@
+package kotlin.jvm.internal;
+
+import kotlin.reflect.KClass;
+import kotlin.reflect.KDeclarationContainer;
+
+/* loaded from: classes5.dex */
+public class PropertyReference0Impl extends PropertyReference0 {
+    public PropertyReference0Impl(KDeclarationContainer kDeclarationContainer, String str, String str2) {
+        super(CallableReference.NO_RECEIVER, ((ClassBasedDeclarationContainer) kDeclarationContainer).getJClass(), str, str2, !(kDeclarationContainer instanceof KClass) ? 1 : 0);
+    }
+
+    public PropertyReference0Impl(Class cls, String str, String str2, int i) {
+        super(CallableReference.NO_RECEIVER, cls, str, str2, i);
+    }
+
+    public PropertyReference0Impl(Object obj, Class cls, String str, String str2, int i) {
+        super(obj, cls, str, str2, i);
+    }
+
+    @Override // kotlin.jvm.internal.PropertyReference0
+    public Object get() {
+        getGetter();
+        throw null;
+    }
+}

decompiled/sources/kotlin/jvm/internal/PropertyReference1.java

@@ -0,0 +1,48 @@
+package kotlin.jvm.internal;
+
+import kotlin.reflect.KCallable;
+import kotlin.reflect.KProperty;
+import kotlin.reflect.KProperty1;
+
+/* loaded from: classes5.dex */
+public abstract class PropertyReference1 extends PropertyReference implements KProperty1 {
+    public abstract /* synthetic */ Object get(Object obj);
+
+    @Override // kotlin.jvm.internal.PropertyReference
+    public /* bridge */ /* synthetic */ KProperty.Getter getGetter() {
+        getGetter();
+        return null;
+    }
+
+    public PropertyReference1() {
+    }
+
+    public PropertyReference1(Object obj) {
+        super(obj);
+    }
+
+    public PropertyReference1(Object obj, Class cls, String str, String str2, int i) {
+        super(obj, cls, str, str2, i);
+    }
+
+    @Override // kotlin.jvm.internal.CallableReference
+    public KCallable computeReflected() {
+        return Reflection.property1(this);
+    }
+
+    @Override // kotlin.jvm.functions.Function1
+    public Object invoke(Object obj) {
+        return get(obj);
+    }
+
+    @Override // kotlin.jvm.internal.PropertyReference
+    public KProperty1.Getter getGetter() {
+        ((KProperty1) getReflected()).getGetter();
+        return null;
+    }
+
+    @Override // kotlin.reflect.KProperty1
+    public Object getDelegate(Object obj) {
+        return ((KProperty1) getReflected()).getDelegate(obj);
+    }
+}

decompiled/sources/kotlin/jvm/internal/PropertyReference1Impl.java

@@ -0,0 +1,25 @@
+package kotlin.jvm.internal;
+
+import kotlin.reflect.KClass;
+import kotlin.reflect.KDeclarationContainer;
+
+/* loaded from: classes5.dex */
+public class PropertyReference1Impl extends PropertyReference1 {
+    public PropertyReference1Impl(KDeclarationContainer kDeclarationContainer, String str, String str2) {
+        super(CallableReference.NO_RECEIVER, ((ClassBasedDeclarationContainer) kDeclarationContainer).getJClass(), str, str2, !(kDeclarationContainer instanceof KClass) ? 1 : 0);
+    }
+
+    public PropertyReference1Impl(Class cls, String str, String str2, int i) {
+        super(CallableReference.NO_RECEIVER, cls, str, str2, i);
+    }
+
+    public PropertyReference1Impl(Object obj, Class cls, String str, String str2, int i) {
+        super(obj, cls, str, str2, i);
+    }
+
+    @Override // kotlin.jvm.internal.PropertyReference1
+    public Object get(Object obj) {
+        getGetter();
+        throw null;
+    }
+}

decompiled/sources/kotlin/jvm/internal/PropertyReference2.java

@@ -0,0 +1,44 @@
+package kotlin.jvm.internal;
+
+import kotlin.reflect.KCallable;
+import kotlin.reflect.KProperty;
+import kotlin.reflect.KProperty2;
+
+/* loaded from: classes5.dex */
+public abstract class PropertyReference2 extends PropertyReference implements KProperty2 {
+    public abstract /* synthetic */ Object get(Object obj, Object obj2);
+
+    @Override // kotlin.jvm.internal.PropertyReference
+    public /* bridge */ /* synthetic */ KProperty.Getter getGetter() {
+        getGetter();
+        return null;
+    }
+
+    public PropertyReference2() {
+    }
+
+    public PropertyReference2(Class cls, String str, String str2, int i) {
+        super(CallableReference.NO_RECEIVER, cls, str, str2, i);
+    }
+
+    @Override // kotlin.jvm.internal.CallableReference
+    public KCallable computeReflected() {
+        return Reflection.property2(this);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public Object invoke(Object obj, Object obj2) {
+        return get(obj, obj2);
+    }
+
+    @Override // kotlin.jvm.internal.PropertyReference
+    public KProperty2.Getter getGetter() {
+        ((KProperty2) getReflected()).getGetter();
+        return null;
+    }
+
+    @Override // kotlin.reflect.KProperty2
+    public Object getDelegate(Object obj, Object obj2) {
+        return ((KProperty2) getReflected()).getDelegate(obj, obj2);
+    }
+}

decompiled/sources/kotlin/jvm/internal/PropertyReference2Impl.java

@@ -0,0 +1,21 @@
+package kotlin.jvm.internal;
+
+import kotlin.reflect.KClass;
+import kotlin.reflect.KDeclarationContainer;
+
+/* loaded from: classes5.dex */
+public class PropertyReference2Impl extends PropertyReference2 {
+    public PropertyReference2Impl(KDeclarationContainer kDeclarationContainer, String str, String str2) {
+        super(((ClassBasedDeclarationContainer) kDeclarationContainer).getJClass(), str, str2, !(kDeclarationContainer instanceof KClass) ? 1 : 0);
+    }
+
+    public PropertyReference2Impl(Class cls, String str, String str2, int i) {
+        super(cls, str, str2, i);
+    }
+
+    @Override // kotlin.jvm.internal.PropertyReference2
+    public Object get(Object obj, Object obj2) {
+        getGetter();
+        throw null;
+    }
+}

decompiled/sources/kotlin/jvm/internal/Ref.java

@@ -0,0 +1,81 @@
+package kotlin.jvm.internal;
+
+import java.io.Serializable;
+
+/* loaded from: classes5.dex */
+public class Ref {
+    private Ref() {
+    }
+
+    public static final class ObjectRef<T> implements Serializable {
+        public T element;
+
+        public String toString() {
+            return String.valueOf(this.element);
+        }
+    }
+
+    public static final class ByteRef implements Serializable {
+        public byte element;
+
+        public String toString() {
+            return String.valueOf((int) this.element);
+        }
+    }
+
+    public static final class ShortRef implements Serializable {
+        public short element;
+
+        public String toString() {
+            return String.valueOf((int) this.element);
+        }
+    }
+
+    public static final class IntRef implements Serializable {
+        public int element;
+
+        public String toString() {
+            return String.valueOf(this.element);
+        }
+    }
+
+    public static final class LongRef implements Serializable {
+        public long element;
+
+        public String toString() {
+            return String.valueOf(this.element);
+        }
+    }
+
+    public static final class FloatRef implements Serializable {
+        public float element;
+
+        public String toString() {
+            return String.valueOf(this.element);
+        }
+    }
+
+    public static final class DoubleRef implements Serializable {
+        public double element;
+
+        public String toString() {
+            return String.valueOf(this.element);
+        }
+    }
+
+    public static final class CharRef implements Serializable {
+        public char element;
+
+        public String toString() {
+            return String.valueOf(this.element);
+        }
+    }
+
+    public static final class BooleanRef implements Serializable {
+        public boolean element;
+
+        public String toString() {
+            return String.valueOf(this.element);
+        }
+    }
+}

decompiled/sources/kotlin/jvm/internal/Reflection.java

@@ -0,0 +1,187 @@
+package kotlin.jvm.internal;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import kotlin.collections.ArraysKt___ArraysKt;
+import kotlin.reflect.KClass;
+import kotlin.reflect.KClassifier;
+import kotlin.reflect.KDeclarationContainer;
+import kotlin.reflect.KFunction;
+import kotlin.reflect.KMutableProperty0;
+import kotlin.reflect.KMutableProperty1;
+import kotlin.reflect.KMutableProperty2;
+import kotlin.reflect.KProperty0;
+import kotlin.reflect.KProperty1;
+import kotlin.reflect.KProperty2;
+import kotlin.reflect.KType;
+import kotlin.reflect.KTypeParameter;
+import kotlin.reflect.KTypeProjection;
+import kotlin.reflect.KVariance;
+
+/* loaded from: classes5.dex */
+public class Reflection {
+    private static final KClass[] EMPTY_K_CLASS_ARRAY;
+    static final String REFLECTION_NOT_AVAILABLE = " (Kotlin reflection is not available)";
+    private static final ReflectionFactory factory;
+
+    static {
+        ReflectionFactory reflectionFactory = null;
+        try {
+            reflectionFactory = (ReflectionFactory) Class.forName("kotlin.reflect.jvm.internal.ReflectionFactoryImpl").newInstance();
+        } catch (ClassCastException | ClassNotFoundException | IllegalAccessException | InstantiationException unused) {
+        }
+        if (reflectionFactory == null) {
+            reflectionFactory = new ReflectionFactory();
+        }
+        factory = reflectionFactory;
+        EMPTY_K_CLASS_ARRAY = new KClass[0];
+    }
+
+    public static KClass createKotlinClass(Class cls) {
+        return factory.createKotlinClass(cls);
+    }
+
+    public static KClass createKotlinClass(Class cls, String str) {
+        return factory.createKotlinClass(cls, str);
+    }
+
+    public static KDeclarationContainer getOrCreateKotlinPackage(Class cls) {
+        return factory.getOrCreateKotlinPackage(cls, "");
+    }
+
+    public static KDeclarationContainer getOrCreateKotlinPackage(Class cls, String str) {
+        return factory.getOrCreateKotlinPackage(cls, str);
+    }
+
+    public static KClass getOrCreateKotlinClass(Class cls) {
+        return factory.getOrCreateKotlinClass(cls);
+    }
+
+    public static KClass getOrCreateKotlinClass(Class cls, String str) {
+        return factory.getOrCreateKotlinClass(cls, str);
+    }
+
+    public static KClass[] getOrCreateKotlinClasses(Class[] clsArr) {
+        int length = clsArr.length;
+        if (length == 0) {
+            return EMPTY_K_CLASS_ARRAY;
+        }
+        KClass[] kClassArr = new KClass[length];
+        for (int i = 0; i < length; i++) {
+            kClassArr[i] = getOrCreateKotlinClass(clsArr[i]);
+        }
+        return kClassArr;
+    }
+
+    public static String renderLambdaToString(Lambda lambda) {
+        return factory.renderLambdaToString(lambda);
+    }
+
+    public static String renderLambdaToString(FunctionBase functionBase) {
+        return factory.renderLambdaToString(functionBase);
+    }
+
+    public static KFunction function(FunctionReference functionReference) {
+        return factory.function(functionReference);
+    }
+
+    public static KProperty0 property0(PropertyReference0 propertyReference0) {
+        return factory.property0(propertyReference0);
+    }
+
+    public static KMutableProperty0 mutableProperty0(MutablePropertyReference0 mutablePropertyReference0) {
+        return factory.mutableProperty0(mutablePropertyReference0);
+    }
+
+    public static KProperty1 property1(PropertyReference1 propertyReference1) {
+        return factory.property1(propertyReference1);
+    }
+
+    public static KMutableProperty1 mutableProperty1(MutablePropertyReference1 mutablePropertyReference1) {
+        return factory.mutableProperty1(mutablePropertyReference1);
+    }
+
+    public static KProperty2 property2(PropertyReference2 propertyReference2) {
+        return factory.property2(propertyReference2);
+    }
+
+    public static KMutableProperty2 mutableProperty2(MutablePropertyReference2 mutablePropertyReference2) {
+        return factory.mutableProperty2(mutablePropertyReference2);
+    }
+
+    public static KType typeOf(KClassifier kClassifier) {
+        return factory.typeOf(kClassifier, Collections.emptyList(), false);
+    }
+
+    public static KType typeOf(Class cls) {
+        return factory.typeOf(getOrCreateKotlinClass(cls), Collections.emptyList(), false);
+    }
+
+    public static KType typeOf(Class cls, KTypeProjection kTypeProjection) {
+        return factory.typeOf(getOrCreateKotlinClass(cls), Collections.singletonList(kTypeProjection), false);
+    }
+
+    public static KType typeOf(Class cls, KTypeProjection kTypeProjection, KTypeProjection kTypeProjection2) {
+        return factory.typeOf(getOrCreateKotlinClass(cls), Arrays.asList(kTypeProjection, kTypeProjection2), false);
+    }
+
+    public static KType typeOf(Class cls, KTypeProjection... kTypeProjectionArr) {
+        List<KTypeProjection> list;
+        ReflectionFactory reflectionFactory = factory;
+        KClass orCreateKotlinClass = getOrCreateKotlinClass(cls);
+        list = ArraysKt___ArraysKt.toList(kTypeProjectionArr);
+        return reflectionFactory.typeOf(orCreateKotlinClass, list, false);
+    }
+
+    public static KType nullableTypeOf(KClassifier kClassifier) {
+        return factory.typeOf(kClassifier, Collections.emptyList(), true);
+    }
+
+    public static KType nullableTypeOf(Class cls) {
+        return factory.typeOf(getOrCreateKotlinClass(cls), Collections.emptyList(), true);
+    }
+
+    public static KType nullableTypeOf(Class cls, KTypeProjection kTypeProjection) {
+        return factory.typeOf(getOrCreateKotlinClass(cls), Collections.singletonList(kTypeProjection), true);
+    }
+
+    public static KType nullableTypeOf(Class cls, KTypeProjection kTypeProjection, KTypeProjection kTypeProjection2) {
+        return factory.typeOf(getOrCreateKotlinClass(cls), Arrays.asList(kTypeProjection, kTypeProjection2), true);
+    }
+
+    public static KType nullableTypeOf(Class cls, KTypeProjection... kTypeProjectionArr) {
+        List<KTypeProjection> list;
+        ReflectionFactory reflectionFactory = factory;
+        KClass orCreateKotlinClass = getOrCreateKotlinClass(cls);
+        list = ArraysKt___ArraysKt.toList(kTypeProjectionArr);
+        return reflectionFactory.typeOf(orCreateKotlinClass, list, true);
+    }
+
+    public static KTypeParameter typeParameter(Object obj, String str, KVariance kVariance, boolean z) {
+        return factory.typeParameter(obj, str, kVariance, z);
+    }
+
+    public static void setUpperBounds(KTypeParameter kTypeParameter, KType kType) {
+        factory.setUpperBounds(kTypeParameter, Collections.singletonList(kType));
+    }
+
+    public static void setUpperBounds(KTypeParameter kTypeParameter, KType... kTypeArr) {
+        List<KType> list;
+        ReflectionFactory reflectionFactory = factory;
+        list = ArraysKt___ArraysKt.toList(kTypeArr);
+        reflectionFactory.setUpperBounds(kTypeParameter, list);
+    }
+
+    public static KType platformType(KType kType, KType kType2) {
+        return factory.platformType(kType, kType2);
+    }
+
+    public static KType mutableCollectionType(KType kType) {
+        return factory.mutableCollectionType(kType);
+    }
+
+    public static KType nothingType(KType kType) {
+        return factory.nothingType(kType);
+    }
+}

decompiled/sources/kotlin/jvm/internal/ReflectionFactory.java

@@ -0,0 +1,105 @@
+package kotlin.jvm.internal;
+
+import java.util.List;
+import kotlin.reflect.KClass;
+import kotlin.reflect.KClassifier;
+import kotlin.reflect.KDeclarationContainer;
+import kotlin.reflect.KFunction;
+import kotlin.reflect.KMutableProperty0;
+import kotlin.reflect.KMutableProperty1;
+import kotlin.reflect.KMutableProperty2;
+import kotlin.reflect.KProperty0;
+import kotlin.reflect.KProperty1;
+import kotlin.reflect.KProperty2;
+import kotlin.reflect.KType;
+import kotlin.reflect.KTypeParameter;
+import kotlin.reflect.KTypeProjection;
+import kotlin.reflect.KVariance;
+
+/* loaded from: classes5.dex */
+public class ReflectionFactory {
+    private static final String KOTLIN_JVM_FUNCTIONS = "kotlin.jvm.functions.";
+
+    public KFunction function(FunctionReference functionReference) {
+        return functionReference;
+    }
+
+    public KMutableProperty0 mutableProperty0(MutablePropertyReference0 mutablePropertyReference0) {
+        return mutablePropertyReference0;
+    }
+
+    public KMutableProperty1 mutableProperty1(MutablePropertyReference1 mutablePropertyReference1) {
+        return mutablePropertyReference1;
+    }
+
+    public KMutableProperty2 mutableProperty2(MutablePropertyReference2 mutablePropertyReference2) {
+        return mutablePropertyReference2;
+    }
+
+    public KProperty0 property0(PropertyReference0 propertyReference0) {
+        return propertyReference0;
+    }
+
+    public KProperty1 property1(PropertyReference1 propertyReference1) {
+        return propertyReference1;
+    }
+
+    public KProperty2 property2(PropertyReference2 propertyReference2) {
+        return propertyReference2;
+    }
+
+    public KClass createKotlinClass(Class cls) {
+        return new ClassReference(cls);
+    }
+
+    public KClass createKotlinClass(Class cls, String str) {
+        return new ClassReference(cls);
+    }
+
+    public KDeclarationContainer getOrCreateKotlinPackage(Class cls, String str) {
+        return new PackageReference(cls, str);
+    }
+
+    public KClass getOrCreateKotlinClass(Class cls) {
+        return new ClassReference(cls);
+    }
+
+    public KClass getOrCreateKotlinClass(Class cls, String str) {
+        return new ClassReference(cls);
+    }
+
+    public String renderLambdaToString(Lambda lambda) {
+        return renderLambdaToString((FunctionBase) lambda);
+    }
+
+    public String renderLambdaToString(FunctionBase functionBase) {
+        String obj = functionBase.getClass().getGenericInterfaces()[0].toString();
+        return obj.startsWith(KOTLIN_JVM_FUNCTIONS) ? obj.substring(21) : obj;
+    }
+
+    public KType typeOf(KClassifier kClassifier, List<KTypeProjection> list, boolean z) {
+        return new TypeReference(kClassifier, list, z);
+    }
+
+    public KTypeParameter typeParameter(Object obj, String str, KVariance kVariance, boolean z) {
+        return new TypeParameterReference(obj, str, kVariance, z);
+    }
+
+    public void setUpperBounds(KTypeParameter kTypeParameter, List<KType> list) {
+        ((TypeParameterReference) kTypeParameter).setUpperBounds(list);
+    }
+
+    public KType platformType(KType kType, KType kType2) {
+        return new TypeReference(kType.getClassifier(), kType.getArguments(), kType2, ((TypeReference) kType).getFlags$kotlin_stdlib());
+    }
+
+    public KType mutableCollectionType(KType kType) {
+        TypeReference typeReference = (TypeReference) kType;
+        return new TypeReference(kType.getClassifier(), kType.getArguments(), typeReference.getPlatformTypeUpperBound$kotlin_stdlib(), typeReference.getFlags$kotlin_stdlib() | 2);
+    }
+
+    public KType nothingType(KType kType) {
+        TypeReference typeReference = (TypeReference) kType;
+        return new TypeReference(kType.getClassifier(), kType.getArguments(), typeReference.getPlatformTypeUpperBound$kotlin_stdlib(), typeReference.getFlags$kotlin_stdlib() | 4);
+    }
+}

decompiled/sources/kotlin/jvm/internal/RepeatableContainer.java

@@ -0,0 +1,12 @@
+package kotlin.jvm.internal;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.ANNOTATION_TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes5.dex */
+public @interface RepeatableContainer {
+}

decompiled/sources/kotlin/jvm/internal/SerializedIr.java

@@ -0,0 +1,13 @@
+package kotlin.jvm.internal;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes5.dex */
+public @interface SerializedIr {
+    String[] b() default {};
+}

decompiled/sources/kotlin/jvm/internal/ShortCompanionObject.java

@@ -0,0 +1,19 @@
+package kotlin.jvm.internal;
+
+/* loaded from: classes5.dex */
+public final class ShortCompanionObject {
+    public static final ShortCompanionObject INSTANCE = new ShortCompanionObject();
+    public static final short MAX_VALUE = Short.MAX_VALUE;
+    public static final short MIN_VALUE = Short.MIN_VALUE;
+    public static final int SIZE_BITS = 16;
+    public static final int SIZE_BYTES = 2;
+
+    public static /* synthetic */ void getSIZE_BITS$annotations() {
+    }
+
+    public static /* synthetic */ void getSIZE_BYTES$annotations() {
+    }
+
+    private ShortCompanionObject() {
+    }
+}

decompiled/sources/kotlin/jvm/internal/ShortSpreadBuilder.java

@@ -0,0 +1,28 @@
+package kotlin.jvm.internal;
+
+/* loaded from: classes5.dex */
+public final class ShortSpreadBuilder extends PrimitiveSpreadBuilder<short[]> {
+    private final short[] values;
+
+    public ShortSpreadBuilder(int i) {
+        super(i);
+        this.values = new short[i];
+    }
+
+    @Override // kotlin.jvm.internal.PrimitiveSpreadBuilder
+    public int getSize(short[] sArr) {
+        Intrinsics.checkNotNullParameter(sArr, "<this>");
+        return sArr.length;
+    }
+
+    public final void add(short s) {
+        short[] sArr = this.values;
+        int position = getPosition();
+        setPosition(position + 1);
+        sArr[position] = s;
+    }
+
+    public final short[] toArray() {
+        return toArray(this.values, new short[size()]);
+    }
+}

decompiled/sources/kotlin/jvm/internal/SourceDebugExtension.java

@@ -0,0 +1,13 @@
+package kotlin.jvm.internal;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes5.dex */
+public @interface SourceDebugExtension {
+    String[] value();
+}

decompiled/sources/kotlin/jvm/internal/SpreadBuilder.java

@@ -0,0 +1,62 @@
+package kotlin.jvm.internal;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+
+/* loaded from: classes5.dex */
+public class SpreadBuilder {
+    private final ArrayList<Object> list;
+
+    public SpreadBuilder(int i) {
+        this.list = new ArrayList<>(i);
+    }
+
+    public void addSpread(Object obj) {
+        if (obj == null) {
+            return;
+        }
+        if (obj instanceof Object[]) {
+            Object[] objArr = (Object[]) obj;
+            if (objArr.length > 0) {
+                ArrayList<Object> arrayList = this.list;
+                arrayList.ensureCapacity(arrayList.size() + objArr.length);
+                Collections.addAll(this.list, objArr);
+                return;
+            }
+            return;
+        }
+        if (obj instanceof Collection) {
+            this.list.addAll((Collection) obj);
+            return;
+        }
+        if (obj instanceof Iterable) {
+            Iterator it = ((Iterable) obj).iterator();
+            while (it.hasNext()) {
+                this.list.add(it.next());
+            }
+            return;
+        }
+        if (obj instanceof Iterator) {
+            Iterator it2 = (Iterator) obj;
+            while (it2.hasNext()) {
+                this.list.add(it2.next());
+            }
+        } else {
+            throw new UnsupportedOperationException("Don't know how to spread " + obj.getClass());
+        }
+    }
+
+    public int size() {
+        return this.list.size();
+    }
+
+    public void add(Object obj) {
+        this.list.add(obj);
+    }
+
+    public Object[] toArray(Object[] objArr) {
+        return this.list.toArray(objArr);
+    }
+}

decompiled/sources/kotlin/jvm/internal/StringCompanionObject.java

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

decompiled/sources/kotlin/jvm/internal/TypeIntrinsics.java

@@ -0,0 +1,358 @@
+package kotlin.jvm.internal;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Map;
+import java.util.Set;
+import kotlin.Function;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function10;
+import kotlin.jvm.functions.Function11;
+import kotlin.jvm.functions.Function12;
+import kotlin.jvm.functions.Function13;
+import kotlin.jvm.functions.Function14;
+import kotlin.jvm.functions.Function15;
+import kotlin.jvm.functions.Function16;
+import kotlin.jvm.functions.Function17;
+import kotlin.jvm.functions.Function18;
+import kotlin.jvm.functions.Function19;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.functions.Function20;
+import kotlin.jvm.functions.Function21;
+import kotlin.jvm.functions.Function22;
+import kotlin.jvm.functions.Function3;
+import kotlin.jvm.functions.Function4;
+import kotlin.jvm.functions.Function5;
+import kotlin.jvm.functions.Function6;
+import kotlin.jvm.functions.Function7;
+import kotlin.jvm.functions.Function8;
+import kotlin.jvm.functions.Function9;
+import kotlin.jvm.internal.markers.KMappedMarker;
+import kotlin.jvm.internal.markers.KMutableCollection;
+import kotlin.jvm.internal.markers.KMutableIterable;
+import kotlin.jvm.internal.markers.KMutableIterator;
+import kotlin.jvm.internal.markers.KMutableList;
+import kotlin.jvm.internal.markers.KMutableListIterator;
+import kotlin.jvm.internal.markers.KMutableMap;
+import kotlin.jvm.internal.markers.KMutableSet;
+
+/* loaded from: classes5.dex */
+public class TypeIntrinsics {
+    private static <T extends Throwable> T sanitizeStackTrace(T t) {
+        return (T) Intrinsics.sanitizeStackTrace(t, TypeIntrinsics.class.getName());
+    }
+
+    public static void throwCce(Object obj, String str) {
+        throwCce((obj == null ? "null" : obj.getClass().getName()) + " cannot be cast to " + str);
+    }
+
+    public static void throwCce(String str) {
+        throw throwCce(new ClassCastException(str));
+    }
+
+    public static ClassCastException throwCce(ClassCastException classCastException) {
+        throw ((ClassCastException) sanitizeStackTrace(classCastException));
+    }
+
+    public static boolean isMutableIterator(Object obj) {
+        return (obj instanceof Iterator) && (!(obj instanceof KMappedMarker) || (obj instanceof KMutableIterator));
+    }
+
+    public static Iterator asMutableIterator(Object obj) {
+        if ((obj instanceof KMappedMarker) && !(obj instanceof KMutableIterator)) {
+            throwCce(obj, "kotlin.collections.MutableIterator");
+        }
+        return castToIterator(obj);
+    }
+
+    public static Iterator asMutableIterator(Object obj, String str) {
+        if ((obj instanceof KMappedMarker) && !(obj instanceof KMutableIterator)) {
+            throwCce(str);
+        }
+        return castToIterator(obj);
+    }
+
+    public static Iterator castToIterator(Object obj) {
+        try {
+            return (Iterator) obj;
+        } catch (ClassCastException e) {
+            throw throwCce(e);
+        }
+    }
+
+    public static boolean isMutableListIterator(Object obj) {
+        return (obj instanceof ListIterator) && (!(obj instanceof KMappedMarker) || (obj instanceof KMutableListIterator));
+    }
+
+    public static ListIterator asMutableListIterator(Object obj) {
+        if ((obj instanceof KMappedMarker) && !(obj instanceof KMutableListIterator)) {
+            throwCce(obj, "kotlin.collections.MutableListIterator");
+        }
+        return castToListIterator(obj);
+    }
+
+    public static ListIterator asMutableListIterator(Object obj, String str) {
+        if ((obj instanceof KMappedMarker) && !(obj instanceof KMutableListIterator)) {
+            throwCce(str);
+        }
+        return castToListIterator(obj);
+    }
+
+    public static ListIterator castToListIterator(Object obj) {
+        try {
+            return (ListIterator) obj;
+        } catch (ClassCastException e) {
+            throw throwCce(e);
+        }
+    }
+
+    public static boolean isMutableIterable(Object obj) {
+        return (obj instanceof Iterable) && (!(obj instanceof KMappedMarker) || (obj instanceof KMutableIterable));
+    }
+
+    public static Iterable asMutableIterable(Object obj) {
+        if ((obj instanceof KMappedMarker) && !(obj instanceof KMutableIterable)) {
+            throwCce(obj, "kotlin.collections.MutableIterable");
+        }
+        return castToIterable(obj);
+    }
+
+    public static Iterable asMutableIterable(Object obj, String str) {
+        if ((obj instanceof KMappedMarker) && !(obj instanceof KMutableIterable)) {
+            throwCce(str);
+        }
+        return castToIterable(obj);
+    }
+
+    public static Iterable castToIterable(Object obj) {
+        try {
+            return (Iterable) obj;
+        } catch (ClassCastException e) {
+            throw throwCce(e);
+        }
+    }
+
+    public static boolean isMutableCollection(Object obj) {
+        return (obj instanceof Collection) && (!(obj instanceof KMappedMarker) || (obj instanceof KMutableCollection));
+    }
+
+    public static Collection asMutableCollection(Object obj) {
+        if ((obj instanceof KMappedMarker) && !(obj instanceof KMutableCollection)) {
+            throwCce(obj, "kotlin.collections.MutableCollection");
+        }
+        return castToCollection(obj);
+    }
+
+    public static Collection asMutableCollection(Object obj, String str) {
+        if ((obj instanceof KMappedMarker) && !(obj instanceof KMutableCollection)) {
+            throwCce(str);
+        }
+        return castToCollection(obj);
+    }
+
+    public static Collection castToCollection(Object obj) {
+        try {
+            return (Collection) obj;
+        } catch (ClassCastException e) {
+            throw throwCce(e);
+        }
+    }
+
+    public static boolean isMutableList(Object obj) {
+        return (obj instanceof List) && (!(obj instanceof KMappedMarker) || (obj instanceof KMutableList));
+    }
+
+    public static List asMutableList(Object obj) {
+        if ((obj instanceof KMappedMarker) && !(obj instanceof KMutableList)) {
+            throwCce(obj, "kotlin.collections.MutableList");
+        }
+        return castToList(obj);
+    }
+
+    public static List asMutableList(Object obj, String str) {
+        if ((obj instanceof KMappedMarker) && !(obj instanceof KMutableList)) {
+            throwCce(str);
+        }
+        return castToList(obj);
+    }
+
+    public static List castToList(Object obj) {
+        try {
+            return (List) obj;
+        } catch (ClassCastException e) {
+            throw throwCce(e);
+        }
+    }
+
+    public static boolean isMutableSet(Object obj) {
+        return (obj instanceof Set) && (!(obj instanceof KMappedMarker) || (obj instanceof KMutableSet));
+    }
+
+    public static Set asMutableSet(Object obj) {
+        if ((obj instanceof KMappedMarker) && !(obj instanceof KMutableSet)) {
+            throwCce(obj, "kotlin.collections.MutableSet");
+        }
+        return castToSet(obj);
+    }
+
+    public static Set asMutableSet(Object obj, String str) {
+        if ((obj instanceof KMappedMarker) && !(obj instanceof KMutableSet)) {
+            throwCce(str);
+        }
+        return castToSet(obj);
+    }
+
+    public static Set castToSet(Object obj) {
+        try {
+            return (Set) obj;
+        } catch (ClassCastException e) {
+            throw throwCce(e);
+        }
+    }
+
+    public static boolean isMutableMap(Object obj) {
+        return (obj instanceof Map) && (!(obj instanceof KMappedMarker) || (obj instanceof KMutableMap));
+    }
+
+    public static Map asMutableMap(Object obj) {
+        if ((obj instanceof KMappedMarker) && !(obj instanceof KMutableMap)) {
+            throwCce(obj, "kotlin.collections.MutableMap");
+        }
+        return castToMap(obj);
+    }
+
+    public static Map asMutableMap(Object obj, String str) {
+        if ((obj instanceof KMappedMarker) && !(obj instanceof KMutableMap)) {
+            throwCce(str);
+        }
+        return castToMap(obj);
+    }
+
+    public static Map castToMap(Object obj) {
+        try {
+            return (Map) obj;
+        } catch (ClassCastException e) {
+            throw throwCce(e);
+        }
+    }
+
+    public static boolean isMutableMapEntry(Object obj) {
+        return (obj instanceof Map.Entry) && (!(obj instanceof KMappedMarker) || (obj instanceof KMutableMap.Entry));
+    }
+
+    public static Map.Entry asMutableMapEntry(Object obj) {
+        if ((obj instanceof KMappedMarker) && !(obj instanceof KMutableMap.Entry)) {
+            throwCce(obj, "kotlin.collections.MutableMap.MutableEntry");
+        }
+        return castToMapEntry(obj);
+    }
+
+    public static Map.Entry asMutableMapEntry(Object obj, String str) {
+        if ((obj instanceof KMappedMarker) && !(obj instanceof KMutableMap.Entry)) {
+            throwCce(str);
+        }
+        return castToMapEntry(obj);
+    }
+
+    public static Map.Entry castToMapEntry(Object obj) {
+        try {
+            return (Map.Entry) obj;
+        } catch (ClassCastException e) {
+            throw throwCce(e);
+        }
+    }
+
+    public static int getFunctionArity(Object obj) {
+        if (obj instanceof FunctionBase) {
+            return ((FunctionBase) obj).getArity();
+        }
+        if (obj instanceof Function0) {
+            return 0;
+        }
+        if (obj instanceof Function1) {
+            return 1;
+        }
+        if (obj instanceof Function2) {
+            return 2;
+        }
+        if (obj instanceof Function3) {
+            return 3;
+        }
+        if (obj instanceof Function4) {
+            return 4;
+        }
+        if (obj instanceof Function5) {
+            return 5;
+        }
+        if (obj instanceof Function6) {
+            return 6;
+        }
+        if (obj instanceof Function7) {
+            return 7;
+        }
+        if (obj instanceof Function8) {
+            return 8;
+        }
+        if (obj instanceof Function9) {
+            return 9;
+        }
+        if (obj instanceof Function10) {
+            return 10;
+        }
+        if (obj instanceof Function11) {
+            return 11;
+        }
+        if (obj instanceof Function12) {
+            return 12;
+        }
+        if (obj instanceof Function13) {
+            return 13;
+        }
+        if (obj instanceof Function14) {
+            return 14;
+        }
+        if (obj instanceof Function15) {
+            return 15;
+        }
+        if (obj instanceof Function16) {
+            return 16;
+        }
+        if (obj instanceof Function17) {
+            return 17;
+        }
+        if (obj instanceof Function18) {
+            return 18;
+        }
+        if (obj instanceof Function19) {
+            return 19;
+        }
+        if (obj instanceof Function20) {
+            return 20;
+        }
+        if (obj instanceof Function21) {
+            return 21;
+        }
+        return obj instanceof Function22 ? 22 : -1;
+    }
+
+    public static boolean isFunctionOfArity(Object obj, int i) {
+        return (obj instanceof Function) && getFunctionArity(obj) == i;
+    }
+
+    public static Object beforeCheckcastToFunctionOfArity(Object obj, int i) {
+        if (obj != null && !isFunctionOfArity(obj, i)) {
+            throwCce(obj, "kotlin.jvm.functions.Function" + i);
+        }
+        return obj;
+    }
+
+    public static Object beforeCheckcastToFunctionOfArity(Object obj, int i, String str) {
+        if (obj != null && !isFunctionOfArity(obj, i)) {
+            throwCce(str);
+        }
+        return obj;
+    }
+}

decompiled/sources/kotlin/jvm/internal/TypeParameterReference.java

@@ -0,0 +1,128 @@
+package kotlin.jvm.internal;
+
+import java.util.List;
+import kotlin.collections.CollectionsKt__CollectionsJVMKt;
+import kotlin.reflect.KType;
+import kotlin.reflect.KTypeParameter;
+import kotlin.reflect.KVariance;
+
+@SourceDebugExtension({"SMAP\nTypeParameterReference.kt\nKotlin\n*S Kotlin\n*F\n+ 1 TypeParameterReference.kt\nkotlin/jvm/internal/TypeParameterReference\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,58:1\n1#2:59\n*E\n"})
+/* loaded from: classes5.dex */
+public final class TypeParameterReference implements KTypeParameter {
+    public static final Companion Companion = new Companion(null);
+    private volatile List<? extends KType> bounds;
+    private final Object container;
+    private final boolean isReified;
+    private final String name;
+    private final KVariance variance;
+
+    public static /* synthetic */ void getUpperBounds$annotations() {
+    }
+
+    @Override // kotlin.reflect.KTypeParameter
+    public String getName() {
+        return this.name;
+    }
+
+    @Override // kotlin.reflect.KTypeParameter
+    public KVariance getVariance() {
+        return this.variance;
+    }
+
+    public boolean isReified() {
+        return this.isReified;
+    }
+
+    public TypeParameterReference(Object obj, String name, KVariance variance, boolean z) {
+        Intrinsics.checkNotNullParameter(name, "name");
+        Intrinsics.checkNotNullParameter(variance, "variance");
+        this.container = obj;
+        this.name = name;
+        this.variance = variance;
+        this.isReified = z;
+    }
+
+    public List<KType> getUpperBounds() {
+        List list = this.bounds;
+        if (list != null) {
+            return list;
+        }
+        List<KType> listOf = CollectionsKt__CollectionsJVMKt.listOf(Reflection.nullableTypeOf(Object.class));
+        this.bounds = listOf;
+        return listOf;
+    }
+
+    public final void setUpperBounds(List<? extends KType> upperBounds) {
+        Intrinsics.checkNotNullParameter(upperBounds, "upperBounds");
+        if (this.bounds == null) {
+            this.bounds = upperBounds;
+            return;
+        }
+        throw new IllegalStateException(("Upper bounds of type parameter '" + this + "' have already been initialized.").toString());
+    }
+
+    public boolean equals(Object obj) {
+        if (obj instanceof TypeParameterReference) {
+            TypeParameterReference typeParameterReference = (TypeParameterReference) obj;
+            if (Intrinsics.areEqual(this.container, typeParameterReference.container) && Intrinsics.areEqual(getName(), typeParameterReference.getName())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        Object obj = this.container;
+        return ((obj != null ? obj.hashCode() : 0) * 31) + getName().hashCode();
+    }
+
+    public String toString() {
+        return Companion.toString(this);
+    }
+
+    public static final class Companion {
+
+        public /* synthetic */ class WhenMappings {
+            public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+            static {
+                int[] iArr = new int[KVariance.values().length];
+                try {
+                    iArr[KVariance.INVARIANT.ordinal()] = 1;
+                } catch (NoSuchFieldError unused) {
+                }
+                try {
+                    iArr[KVariance.IN.ordinal()] = 2;
+                } catch (NoSuchFieldError unused2) {
+                }
+                try {
+                    iArr[KVariance.OUT.ordinal()] = 3;
+                } catch (NoSuchFieldError unused3) {
+                }
+                $EnumSwitchMapping$0 = iArr;
+            }
+        }
+
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final String toString(KTypeParameter typeParameter) {
+            Intrinsics.checkNotNullParameter(typeParameter, "typeParameter");
+            StringBuilder sb = new StringBuilder();
+            int i = WhenMappings.$EnumSwitchMapping$0[typeParameter.getVariance().ordinal()];
+            if (i == 2) {
+                sb.append("in ");
+            } else if (i == 3) {
+                sb.append("out ");
+            }
+            sb.append(typeParameter.getName());
+            String sb2 = sb.toString();
+            Intrinsics.checkNotNullExpressionValue(sb2, "toString(...)");
+            return sb2;
+        }
+    }
+}