Primer paso de la investigacion. Se aportan el .apk, las carpetas con el apk extraido y el apk descompilado. El archivo API_DOCUMENTATION.md es un archivo donde se anotaran los descubrimientos del funcionamiento de la API, y los .py son scripts para probar la funcionalidad de la API con los métodos que vayamos encontrando. Finalmente, los archivos .js son scripts de Frida para extraer informacion de la APP durante la ejecucion.

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/builtins/BuiltInsBinaryVersion.java

@@ -0,0 +1,65 @@
+package kotlin.reflect.jvm.internal.impl.metadata.builtins;
+
+import java.io.DataInputStream;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import kotlin.collections.CollectionsKt__IterablesKt;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.collections.IntIterator;
+import kotlin.jvm.JvmField;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.ranges.IntRange;
+import kotlin.reflect.jvm.internal.impl.metadata.deserialization.BinaryVersion;
+
+/* loaded from: classes3.dex */
+public final class BuiltInsBinaryVersion extends BinaryVersion {
+    public static final Companion Companion = new Companion(null);
+
+    @JvmField
+    public static final BuiltInsBinaryVersion INSTANCE = new BuiltInsBinaryVersion(1, 0, 7);
+
+    @JvmField
+    public static final BuiltInsBinaryVersion INVALID_VERSION = new BuiltInsBinaryVersion(new int[0]);
+
+    @SourceDebugExtension({"SMAP\nBuiltInsBinaryVersion.kt\nKotlin\n*S Kotlin\n*F\n+ 1 BuiltInsBinaryVersion.kt\norg/jetbrains/kotlin/metadata/builtins/BuiltInsBinaryVersion$Companion\n+ 2 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,40:1\n1549#2:41\n1620#2,3:42\n*S KotlinDebug\n*F\n+ 1 BuiltInsBinaryVersion.kt\norg/jetbrains/kotlin/metadata/builtins/BuiltInsBinaryVersion$Companion\n*L\n36#1:41\n36#1:42,3\n*E\n"})
+    /* loaded from: classes3.dex */
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public final BuiltInsBinaryVersion readFrom(InputStream stream) {
+            int collectionSizeOrDefault;
+            int[] intArray;
+            Intrinsics.checkNotNullParameter(stream, "stream");
+            DataInputStream dataInputStream = new DataInputStream(stream);
+            IntRange intRange = new IntRange(1, dataInputStream.readInt());
+            collectionSizeOrDefault = CollectionsKt__IterablesKt.collectionSizeOrDefault(intRange, 10);
+            ArrayList arrayList = new ArrayList(collectionSizeOrDefault);
+            Iterator<Integer> it = intRange.iterator();
+            while (it.hasNext()) {
+                ((IntIterator) it).nextInt();
+                arrayList.add(Integer.valueOf(dataInputStream.readInt()));
+            }
+            intArray = CollectionsKt___CollectionsKt.toIntArray(arrayList);
+            return new BuiltInsBinaryVersion(Arrays.copyOf(intArray, intArray.length));
+        }
+
+        private Companion() {
+        }
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public BuiltInsBinaryVersion(int... numbers) {
+        super(Arrays.copyOf(numbers, numbers.length));
+        Intrinsics.checkNotNullParameter(numbers, "numbers");
+    }
+
+    public boolean isCompatibleWithCurrentCompilerVersion() {
+        return isCompatibleTo(INSTANCE);
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/builtins/BuiltInsProtoBuf.java

@@ -0,0 +1,55 @@
+package kotlin.reflect.jvm.internal.impl.metadata.builtins;
+
+import java.util.List;
+import kotlin.reflect.jvm.internal.impl.metadata.ProtoBuf;
+import kotlin.reflect.jvm.internal.impl.protobuf.ExtensionRegistryLite;
+import kotlin.reflect.jvm.internal.impl.protobuf.GeneratedMessageLite;
+import kotlin.reflect.jvm.internal.impl.protobuf.WireFormat;
+
+/* loaded from: classes3.dex */
+public final class BuiltInsProtoBuf {
+    public static final GeneratedMessageLite.GeneratedExtension<ProtoBuf.Class, List<ProtoBuf.Annotation>> classAnnotation;
+    public static final GeneratedMessageLite.GeneratedExtension<ProtoBuf.Property, ProtoBuf.Annotation.Argument.Value> compileTimeValue;
+    public static final GeneratedMessageLite.GeneratedExtension<ProtoBuf.Constructor, List<ProtoBuf.Annotation>> constructorAnnotation;
+    public static final GeneratedMessageLite.GeneratedExtension<ProtoBuf.EnumEntry, List<ProtoBuf.Annotation>> enumEntryAnnotation;
+    public static final GeneratedMessageLite.GeneratedExtension<ProtoBuf.Function, List<ProtoBuf.Annotation>> functionAnnotation;
+    public static final GeneratedMessageLite.GeneratedExtension<ProtoBuf.Package, Integer> packageFqName = GeneratedMessageLite.newSingularGeneratedExtension(ProtoBuf.Package.getDefaultInstance(), 0, null, null, 151, WireFormat.FieldType.INT32, Integer.class);
+    public static final GeneratedMessageLite.GeneratedExtension<ProtoBuf.ValueParameter, List<ProtoBuf.Annotation>> parameterAnnotation;
+    public static final GeneratedMessageLite.GeneratedExtension<ProtoBuf.Property, List<ProtoBuf.Annotation>> propertyAnnotation;
+    public static final GeneratedMessageLite.GeneratedExtension<ProtoBuf.Property, List<ProtoBuf.Annotation>> propertyGetterAnnotation;
+    public static final GeneratedMessageLite.GeneratedExtension<ProtoBuf.Property, List<ProtoBuf.Annotation>> propertySetterAnnotation;
+    public static final GeneratedMessageLite.GeneratedExtension<ProtoBuf.Type, List<ProtoBuf.Annotation>> typeAnnotation;
+    public static final GeneratedMessageLite.GeneratedExtension<ProtoBuf.TypeParameter, List<ProtoBuf.Annotation>> typeParameterAnnotation;
+
+    static {
+        ProtoBuf.Class defaultInstance = ProtoBuf.Class.getDefaultInstance();
+        ProtoBuf.Annotation defaultInstance2 = ProtoBuf.Annotation.getDefaultInstance();
+        WireFormat.FieldType fieldType = WireFormat.FieldType.MESSAGE;
+        classAnnotation = GeneratedMessageLite.newRepeatedGeneratedExtension(defaultInstance, defaultInstance2, null, 150, fieldType, false, ProtoBuf.Annotation.class);
+        constructorAnnotation = GeneratedMessageLite.newRepeatedGeneratedExtension(ProtoBuf.Constructor.getDefaultInstance(), ProtoBuf.Annotation.getDefaultInstance(), null, 150, fieldType, false, ProtoBuf.Annotation.class);
+        functionAnnotation = GeneratedMessageLite.newRepeatedGeneratedExtension(ProtoBuf.Function.getDefaultInstance(), ProtoBuf.Annotation.getDefaultInstance(), null, 150, fieldType, false, ProtoBuf.Annotation.class);
+        propertyAnnotation = GeneratedMessageLite.newRepeatedGeneratedExtension(ProtoBuf.Property.getDefaultInstance(), ProtoBuf.Annotation.getDefaultInstance(), null, 150, fieldType, false, ProtoBuf.Annotation.class);
+        propertyGetterAnnotation = GeneratedMessageLite.newRepeatedGeneratedExtension(ProtoBuf.Property.getDefaultInstance(), ProtoBuf.Annotation.getDefaultInstance(), null, 152, fieldType, false, ProtoBuf.Annotation.class);
+        propertySetterAnnotation = GeneratedMessageLite.newRepeatedGeneratedExtension(ProtoBuf.Property.getDefaultInstance(), ProtoBuf.Annotation.getDefaultInstance(), null, 153, fieldType, false, ProtoBuf.Annotation.class);
+        compileTimeValue = GeneratedMessageLite.newSingularGeneratedExtension(ProtoBuf.Property.getDefaultInstance(), ProtoBuf.Annotation.Argument.Value.getDefaultInstance(), ProtoBuf.Annotation.Argument.Value.getDefaultInstance(), null, 151, fieldType, ProtoBuf.Annotation.Argument.Value.class);
+        enumEntryAnnotation = GeneratedMessageLite.newRepeatedGeneratedExtension(ProtoBuf.EnumEntry.getDefaultInstance(), ProtoBuf.Annotation.getDefaultInstance(), null, 150, fieldType, false, ProtoBuf.Annotation.class);
+        parameterAnnotation = GeneratedMessageLite.newRepeatedGeneratedExtension(ProtoBuf.ValueParameter.getDefaultInstance(), ProtoBuf.Annotation.getDefaultInstance(), null, 150, fieldType, false, ProtoBuf.Annotation.class);
+        typeAnnotation = GeneratedMessageLite.newRepeatedGeneratedExtension(ProtoBuf.Type.getDefaultInstance(), ProtoBuf.Annotation.getDefaultInstance(), null, 150, fieldType, false, ProtoBuf.Annotation.class);
+        typeParameterAnnotation = GeneratedMessageLite.newRepeatedGeneratedExtension(ProtoBuf.TypeParameter.getDefaultInstance(), ProtoBuf.Annotation.getDefaultInstance(), null, 150, fieldType, false, ProtoBuf.Annotation.class);
+    }
+
+    public static void registerAllExtensions(ExtensionRegistryLite extensionRegistryLite) {
+        extensionRegistryLite.add(packageFqName);
+        extensionRegistryLite.add(classAnnotation);
+        extensionRegistryLite.add(constructorAnnotation);
+        extensionRegistryLite.add(functionAnnotation);
+        extensionRegistryLite.add(propertyAnnotation);
+        extensionRegistryLite.add(propertyGetterAnnotation);
+        extensionRegistryLite.add(propertySetterAnnotation);
+        extensionRegistryLite.add(compileTimeValue);
+        extensionRegistryLite.add(enumEntryAnnotation);
+        extensionRegistryLite.add(parameterAnnotation);
+        extensionRegistryLite.add(typeAnnotation);
+        extensionRegistryLite.add(typeParameterAnnotation);
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/builtins/ReadPackageFragmentKt.java

@@ -0,0 +1,33 @@
+package kotlin.reflect.jvm.internal.impl.metadata.builtins;
+
+import java.io.InputStream;
+import kotlin.Pair;
+import kotlin.TuplesKt;
+import kotlin.io.CloseableKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.reflect.jvm.internal.impl.metadata.ProtoBuf;
+import kotlin.reflect.jvm.internal.impl.protobuf.ExtensionRegistryLite;
+
+@SourceDebugExtension({"SMAP\nreadPackageFragment.kt\nKotlin\n*S Kotlin\n*F\n+ 1 readPackageFragment.kt\norg/jetbrains/kotlin/metadata/builtins/ReadPackageFragmentKt\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,23:1\n1#2:24\n*E\n"})
+/* loaded from: classes3.dex */
+public final class ReadPackageFragmentKt {
+    public static final Pair<ProtoBuf.PackageFragment, BuiltInsBinaryVersion> readBuiltinsPackageFragment(InputStream inputStream) {
+        ProtoBuf.PackageFragment packageFragment;
+        Intrinsics.checkNotNullParameter(inputStream, "<this>");
+        try {
+            BuiltInsBinaryVersion readFrom = BuiltInsBinaryVersion.Companion.readFrom(inputStream);
+            if (readFrom.isCompatibleWithCurrentCompilerVersion()) {
+                ExtensionRegistryLite newInstance = ExtensionRegistryLite.newInstance();
+                BuiltInsProtoBuf.registerAllExtensions(newInstance);
+                packageFragment = ProtoBuf.PackageFragment.parseFrom(inputStream, newInstance);
+            } else {
+                packageFragment = null;
+            }
+            Pair<ProtoBuf.PackageFragment, BuiltInsBinaryVersion> pair = TuplesKt.to(packageFragment, readFrom);
+            CloseableKt.closeFinally(inputStream, null);
+            return pair;
+        } finally {
+        }
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/deserialization/BinaryVersion.java

@@ -0,0 +1,139 @@
+package kotlin.reflect.jvm.internal.impl.metadata.deserialization;
+
+import C.w;
+import java.util.ArrayList;
+import java.util.List;
+import kotlin.collections.ArraysKt;
+import kotlin.collections.CollectionsKt;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nBinaryVersion.kt\nKotlin\n*S Kotlin\n*F\n+ 1 BinaryVersion.kt\norg/jetbrains/kotlin/metadata/deserialization/BinaryVersion\n+ 2 _Arrays.kt\nkotlin/collections/ArraysKt___ArraysKt\n*L\n1#1,101:1\n5306#2,7:102\n*S KotlinDebug\n*F\n+ 1 BinaryVersion.kt\norg/jetbrains/kotlin/metadata/deserialization/BinaryVersion\n*L\n73#1:102,7\n*E\n"})
+/* loaded from: classes3.dex */
+public abstract class BinaryVersion {
+    public static final Companion Companion = new Companion(null);
+    private final int major;
+    private final int minor;
+    private final int[] numbers;
+    private final int patch;
+    private final List<Integer> rest;
+
+    @SourceDebugExtension({"SMAP\nBinaryVersion.kt\nKotlin\n*S Kotlin\n*F\n+ 1 BinaryVersion.kt\norg/jetbrains/kotlin/metadata/deserialization/BinaryVersion$Companion\n+ 2 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n+ 3 ArraysJVM.kt\nkotlin/collections/ArraysKt__ArraysJVMKt\n*L\n1#1,101:1\n1549#2:102\n1620#2,3:103\n37#3,2:106\n*S KotlinDebug\n*F\n+ 1 BinaryVersion.kt\norg/jetbrains/kotlin/metadata/deserialization/BinaryVersion$Companion\n*L\n97#1:102\n97#1:103,3\n98#1:106,2\n*E\n"})
+    /* loaded from: classes3.dex */
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+
+    public BinaryVersion(int... numbers) {
+        List<Integer> emptyList;
+        Intrinsics.checkNotNullParameter(numbers, "numbers");
+        this.numbers = numbers;
+        Integer orNull = ArraysKt.getOrNull(numbers, 0);
+        this.major = orNull != null ? orNull.intValue() : -1;
+        Integer orNull2 = ArraysKt.getOrNull(numbers, 1);
+        this.minor = orNull2 != null ? orNull2.intValue() : -1;
+        Integer orNull3 = ArraysKt.getOrNull(numbers, 2);
+        this.patch = orNull3 != null ? orNull3.intValue() : -1;
+        if (numbers.length <= 3) {
+            emptyList = CollectionsKt.emptyList();
+        } else {
+            if (numbers.length > 1024) {
+                throw new IllegalArgumentException(w.p(new StringBuilder("BinaryVersion with length more than 1024 are not supported. Provided length "), numbers.length, '.'));
+            }
+            emptyList = CollectionsKt.toList(ArraysKt.asList(numbers).subList(3, numbers.length));
+        }
+        this.rest = emptyList;
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == null || !Intrinsics.areEqual(getClass(), obj.getClass())) {
+            return false;
+        }
+        BinaryVersion binaryVersion = (BinaryVersion) obj;
+        return this.major == binaryVersion.major && this.minor == binaryVersion.minor && this.patch == binaryVersion.patch && Intrinsics.areEqual(this.rest, binaryVersion.rest);
+    }
+
+    public final int getMajor() {
+        return this.major;
+    }
+
+    public final int getMinor() {
+        return this.minor;
+    }
+
+    public int hashCode() {
+        int i = this.major;
+        int i4 = (i * 31) + this.minor + i;
+        int i5 = (i4 * 31) + this.patch + i4;
+        return this.rest.hashCode() + (i5 * 31) + i5;
+    }
+
+    public final boolean isAtLeast(BinaryVersion version) {
+        Intrinsics.checkNotNullParameter(version, "version");
+        return isAtLeast(version.major, version.minor, version.patch);
+    }
+
+    public final boolean isAtMost(int i, int i4, int i5) {
+        int i6 = this.major;
+        if (i6 < i) {
+            return true;
+        }
+        if (i6 > i) {
+            return false;
+        }
+        int i7 = this.minor;
+        if (i7 < i4) {
+            return true;
+        }
+        return i7 <= i4 && this.patch <= i5;
+    }
+
+    public final boolean isCompatibleTo(BinaryVersion ourVersion) {
+        Intrinsics.checkNotNullParameter(ourVersion, "ourVersion");
+        int i = this.major;
+        return i == 0 ? ourVersion.major == 0 && this.minor == ourVersion.minor : i == ourVersion.major && this.minor <= ourVersion.minor;
+    }
+
+    public final int[] toArray() {
+        return this.numbers;
+    }
+
+    public String toString() {
+        String joinToString$default;
+        int[] array = toArray();
+        ArrayList arrayList = new ArrayList();
+        for (int i : array) {
+            if (i == -1) {
+                break;
+            }
+            arrayList.add(Integer.valueOf(i));
+        }
+        if (arrayList.isEmpty()) {
+            return "unknown";
+        }
+        joinToString$default = CollectionsKt___CollectionsKt.joinToString$default(arrayList, ".", null, null, 0, null, null, 62, null);
+        return joinToString$default;
+    }
+
+    public final boolean isAtLeast(int i, int i4, int i5) {
+        int i6 = this.major;
+        if (i6 > i) {
+            return true;
+        }
+        if (i6 < i) {
+            return false;
+        }
+        int i7 = this.minor;
+        if (i7 > i4) {
+            return true;
+        }
+        return i7 >= i4 && this.patch >= i5;
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/deserialization/Flags.java

@@ -0,0 +1,325 @@
+package kotlin.reflect.jvm.internal.impl.metadata.deserialization;
+
+import kotlin.reflect.jvm.internal.impl.metadata.ProtoBuf;
+import kotlin.reflect.jvm.internal.impl.protobuf.Internal;
+
+/* loaded from: classes3.dex */
+public class Flags {
+    public static final FlagField<ProtoBuf.Class.Kind> CLASS_KIND;
+    public static final BooleanFlagField DECLARES_DEFAULT_VALUE;
+    public static final BooleanFlagField DEFINITELY_NOT_NULL_TYPE;
+    public static final BooleanFlagField HAS_ANNOTATIONS;
+    public static final BooleanFlagField HAS_CONSTANT;
+    public static final BooleanFlagField HAS_ENUM_ENTRIES;
+    public static final BooleanFlagField HAS_GETTER;
+    public static final BooleanFlagField HAS_SETTER;
+    public static final BooleanFlagField IS_CONST;
+    public static final BooleanFlagField IS_CONSTRUCTOR_WITH_NON_STABLE_PARAMETER_NAMES;
+    public static final BooleanFlagField IS_CROSSINLINE;
+    public static final BooleanFlagField IS_DATA;
+    public static final BooleanFlagField IS_DELEGATED;
+    public static final BooleanFlagField IS_EXPECT_CLASS;
+    public static final BooleanFlagField IS_EXPECT_FUNCTION;
+    public static final BooleanFlagField IS_EXPECT_PROPERTY;
+    public static final BooleanFlagField IS_EXTERNAL_ACCESSOR;
+    public static final BooleanFlagField IS_EXTERNAL_CLASS;
+    public static final BooleanFlagField IS_EXTERNAL_FUNCTION;
+    public static final BooleanFlagField IS_EXTERNAL_PROPERTY;
+    public static final BooleanFlagField IS_FUNCTION_WITH_NON_STABLE_PARAMETER_NAMES;
+    public static final BooleanFlagField IS_FUN_INTERFACE;
+    public static final BooleanFlagField IS_INFIX;
+    public static final BooleanFlagField IS_INLINE;
+    public static final BooleanFlagField IS_INLINE_ACCESSOR;
+    public static final BooleanFlagField IS_INNER;
+    public static final BooleanFlagField IS_LATEINIT;
+    public static final BooleanFlagField IS_NEGATED;
+    public static final BooleanFlagField IS_NOINLINE;
+    public static final BooleanFlagField IS_NOT_DEFAULT;
+    public static final BooleanFlagField IS_NULL_CHECK_PREDICATE;
+    public static final BooleanFlagField IS_OPERATOR;
+    public static final BooleanFlagField IS_SECONDARY;
+    public static final BooleanFlagField IS_SUSPEND;
+    public static final BooleanFlagField IS_TAILREC;
+    public static final BooleanFlagField IS_UNSIGNED;
+    public static final BooleanFlagField IS_VALUE_CLASS;
+    public static final BooleanFlagField IS_VAR;
+    public static final FlagField<ProtoBuf.MemberKind> MEMBER_KIND;
+    public static final FlagField<ProtoBuf.Modality> MODALITY;
+    public static final BooleanFlagField SUSPEND_TYPE;
+    public static final FlagField<ProtoBuf.Visibility> VISIBILITY;
+
+    /* loaded from: classes3.dex */
+    public static class BooleanFlagField extends FlagField<Boolean> {
+        private static /* synthetic */ void $$$reportNull$$$0(int i) {
+            throw new IllegalStateException("@NotNull method kotlin/reflect/jvm/internal/impl/metadata/deserialization/Flags$BooleanFlagField.get must not return null");
+        }
+
+        public BooleanFlagField(int i) {
+            super(i, 1);
+        }
+
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // kotlin.reflect.jvm.internal.impl.metadata.deserialization.Flags.FlagField
+        public Boolean get(int i) {
+            return Boolean.valueOf(((1 << this.offset) & i) != 0);
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.metadata.deserialization.Flags.FlagField
+        public int toFlags(Boolean bool) {
+            if (bool.booleanValue()) {
+                return 1 << this.offset;
+            }
+            return 0;
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static class EnumLiteFlagField<E extends Internal.EnumLite> extends FlagField<E> {
+        private final E[] values;
+
+        private static /* synthetic */ void $$$reportNull$$$0(int i) {
+            throw new IllegalArgumentException("Argument for @NotNull parameter 'enumEntries' of kotlin/reflect/jvm/internal/impl/metadata/deserialization/Flags$EnumLiteFlagField.bitWidth must not be null");
+        }
+
+        public EnumLiteFlagField(int i, E[] eArr) {
+            super(i, bitWidth(eArr));
+            this.values = eArr;
+        }
+
+        private static <E> int bitWidth(E[] eArr) {
+            if (eArr == null) {
+                $$$reportNull$$$0(0);
+            }
+            int length = eArr.length - 1;
+            if (length == 0) {
+                return 1;
+            }
+            for (int i = 31; i >= 0; i--) {
+                if (((1 << i) & length) != 0) {
+                    return i + 1;
+                }
+            }
+            throw new IllegalStateException("Empty enum: " + eArr.getClass());
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.metadata.deserialization.Flags.FlagField
+        public E get(int i) {
+            int i4 = (1 << this.bitWidth) - 1;
+            int i5 = this.offset;
+            int i6 = (i & (i4 << i5)) >> i5;
+            for (E e4 : this.values) {
+                if (e4.getNumber() == i6) {
+                    return e4;
+                }
+            }
+            return null;
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.metadata.deserialization.Flags.FlagField
+        public int toFlags(E e4) {
+            return e4.getNumber() << this.offset;
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static abstract class FlagField<E> {
+        public final int bitWidth;
+        public final int offset;
+
+        /* JADX WARN: Incorrect types in method signature: <E::Lkotlin/reflect/jvm/internal/impl/protobuf/Internal$EnumLite;>(Lkotlin/reflect/jvm/internal/impl/metadata/deserialization/Flags$FlagField<*>;[TE;)Lkotlin/reflect/jvm/internal/impl/metadata/deserialization/Flags$FlagField<TE;>; */
+        public static FlagField after(FlagField flagField, Internal.EnumLite[] enumLiteArr) {
+            return new EnumLiteFlagField(flagField.offset + flagField.bitWidth, enumLiteArr);
+        }
+
+        public static BooleanFlagField booleanAfter(FlagField<?> flagField) {
+            return new BooleanFlagField(flagField.offset + flagField.bitWidth);
+        }
+
+        public static BooleanFlagField booleanFirst() {
+            return new BooleanFlagField(0);
+        }
+
+        public abstract E get(int i);
+
+        public abstract int toFlags(E e4);
+
+        private FlagField(int i, int i4) {
+            this.offset = i;
+            this.bitWidth = i4;
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:17:0x0036  */
+    /* JADX WARN: Removed duplicated region for block: B:21:0x003b  */
+    /* JADX WARN: Removed duplicated region for block: B:22:0x0040  */
+    /* JADX WARN: Removed duplicated region for block: B:23:0x0045  */
+    /* JADX WARN: Removed duplicated region for block: B:24:0x004a  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private static /* synthetic */ void $$$reportNull$$$0(int r5) {
+        /*
+            r0 = 3
+            java.lang.Object[] r0 = new java.lang.Object[r0]
+            r1 = 1
+            r2 = 0
+            r3 = 2
+            if (r5 == r1) goto L2b
+            if (r5 == r3) goto L26
+            r4 = 5
+            if (r5 == r4) goto L2b
+            r4 = 6
+            if (r5 == r4) goto L21
+            r4 = 8
+            if (r5 == r4) goto L2b
+            r4 = 9
+            if (r5 == r4) goto L21
+            r4 = 11
+            if (r5 == r4) goto L2b
+            java.lang.String r4 = "visibility"
+            r0[r2] = r4
+            goto L2f
+        L21:
+            java.lang.String r4 = "memberKind"
+            r0[r2] = r4
+            goto L2f
+        L26:
+            java.lang.String r4 = "kind"
+            r0[r2] = r4
+            goto L2f
+        L2b:
+            java.lang.String r4 = "modality"
+            r0[r2] = r4
+        L2f:
+            java.lang.String r2 = "kotlin/reflect/jvm/internal/impl/metadata/deserialization/Flags"
+            r0[r1] = r2
+            switch(r5) {
+                case 3: goto L4a;
+                case 4: goto L45;
+                case 5: goto L45;
+                case 6: goto L45;
+                case 7: goto L40;
+                case 8: goto L40;
+                case 9: goto L40;
+                case 10: goto L3b;
+                case 11: goto L3b;
+                default: goto L36;
+            }
+        L36:
+            java.lang.String r5 = "getClassFlags"
+            r0[r3] = r5
+            goto L4e
+        L3b:
+            java.lang.String r5 = "getAccessorFlags"
+            r0[r3] = r5
+            goto L4e
+        L40:
+            java.lang.String r5 = "getPropertyFlags"
+            r0[r3] = r5
+            goto L4e
+        L45:
+            java.lang.String r5 = "getFunctionFlags"
+            r0[r3] = r5
+            goto L4e
+        L4a:
+            java.lang.String r5 = "getConstructorFlags"
+            r0[r3] = r5
+        L4e:
+            java.lang.String r5 = "Argument for @NotNull parameter '%s' of %s.%s must not be null"
+            java.lang.String r5 = java.lang.String.format(r5, r0)
+            java.lang.IllegalArgumentException r0 = new java.lang.IllegalArgumentException
+            r0.<init>(r5)
+            throw r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlin.reflect.jvm.internal.impl.metadata.deserialization.Flags.$$$reportNull$$$0(int):void");
+    }
+
+    static {
+        BooleanFlagField booleanFirst = FlagField.booleanFirst();
+        SUSPEND_TYPE = booleanFirst;
+        DEFINITELY_NOT_NULL_TYPE = FlagField.booleanAfter(booleanFirst);
+        BooleanFlagField booleanFirst2 = FlagField.booleanFirst();
+        HAS_ANNOTATIONS = booleanFirst2;
+        FlagField<ProtoBuf.Visibility> after = FlagField.after(booleanFirst2, ProtoBuf.Visibility.values());
+        VISIBILITY = after;
+        FlagField<ProtoBuf.Modality> after2 = FlagField.after(after, ProtoBuf.Modality.values());
+        MODALITY = after2;
+        FlagField<ProtoBuf.Class.Kind> after3 = FlagField.after(after2, ProtoBuf.Class.Kind.values());
+        CLASS_KIND = after3;
+        BooleanFlagField booleanAfter = FlagField.booleanAfter(after3);
+        IS_INNER = booleanAfter;
+        BooleanFlagField booleanAfter2 = FlagField.booleanAfter(booleanAfter);
+        IS_DATA = booleanAfter2;
+        BooleanFlagField booleanAfter3 = FlagField.booleanAfter(booleanAfter2);
+        IS_EXTERNAL_CLASS = booleanAfter3;
+        BooleanFlagField booleanAfter4 = FlagField.booleanAfter(booleanAfter3);
+        IS_EXPECT_CLASS = booleanAfter4;
+        BooleanFlagField booleanAfter5 = FlagField.booleanAfter(booleanAfter4);
+        IS_VALUE_CLASS = booleanAfter5;
+        BooleanFlagField booleanAfter6 = FlagField.booleanAfter(booleanAfter5);
+        IS_FUN_INTERFACE = booleanAfter6;
+        HAS_ENUM_ENTRIES = FlagField.booleanAfter(booleanAfter6);
+        BooleanFlagField booleanAfter7 = FlagField.booleanAfter(after);
+        IS_SECONDARY = booleanAfter7;
+        IS_CONSTRUCTOR_WITH_NON_STABLE_PARAMETER_NAMES = FlagField.booleanAfter(booleanAfter7);
+        FlagField<ProtoBuf.MemberKind> after4 = FlagField.after(after2, ProtoBuf.MemberKind.values());
+        MEMBER_KIND = after4;
+        BooleanFlagField booleanAfter8 = FlagField.booleanAfter(after4);
+        IS_OPERATOR = booleanAfter8;
+        BooleanFlagField booleanAfter9 = FlagField.booleanAfter(booleanAfter8);
+        IS_INFIX = booleanAfter9;
+        BooleanFlagField booleanAfter10 = FlagField.booleanAfter(booleanAfter9);
+        IS_INLINE = booleanAfter10;
+        BooleanFlagField booleanAfter11 = FlagField.booleanAfter(booleanAfter10);
+        IS_TAILREC = booleanAfter11;
+        BooleanFlagField booleanAfter12 = FlagField.booleanAfter(booleanAfter11);
+        IS_EXTERNAL_FUNCTION = booleanAfter12;
+        BooleanFlagField booleanAfter13 = FlagField.booleanAfter(booleanAfter12);
+        IS_SUSPEND = booleanAfter13;
+        BooleanFlagField booleanAfter14 = FlagField.booleanAfter(booleanAfter13);
+        IS_EXPECT_FUNCTION = booleanAfter14;
+        IS_FUNCTION_WITH_NON_STABLE_PARAMETER_NAMES = FlagField.booleanAfter(booleanAfter14);
+        BooleanFlagField booleanAfter15 = FlagField.booleanAfter(after4);
+        IS_VAR = booleanAfter15;
+        BooleanFlagField booleanAfter16 = FlagField.booleanAfter(booleanAfter15);
+        HAS_GETTER = booleanAfter16;
+        BooleanFlagField booleanAfter17 = FlagField.booleanAfter(booleanAfter16);
+        HAS_SETTER = booleanAfter17;
+        BooleanFlagField booleanAfter18 = FlagField.booleanAfter(booleanAfter17);
+        IS_CONST = booleanAfter18;
+        BooleanFlagField booleanAfter19 = FlagField.booleanAfter(booleanAfter18);
+        IS_LATEINIT = booleanAfter19;
+        BooleanFlagField booleanAfter20 = FlagField.booleanAfter(booleanAfter19);
+        HAS_CONSTANT = booleanAfter20;
+        BooleanFlagField booleanAfter21 = FlagField.booleanAfter(booleanAfter20);
+        IS_EXTERNAL_PROPERTY = booleanAfter21;
+        BooleanFlagField booleanAfter22 = FlagField.booleanAfter(booleanAfter21);
+        IS_DELEGATED = booleanAfter22;
+        IS_EXPECT_PROPERTY = FlagField.booleanAfter(booleanAfter22);
+        BooleanFlagField booleanAfter23 = FlagField.booleanAfter(booleanFirst2);
+        DECLARES_DEFAULT_VALUE = booleanAfter23;
+        BooleanFlagField booleanAfter24 = FlagField.booleanAfter(booleanAfter23);
+        IS_CROSSINLINE = booleanAfter24;
+        IS_NOINLINE = FlagField.booleanAfter(booleanAfter24);
+        BooleanFlagField booleanAfter25 = FlagField.booleanAfter(after2);
+        IS_NOT_DEFAULT = booleanAfter25;
+        BooleanFlagField booleanAfter26 = FlagField.booleanAfter(booleanAfter25);
+        IS_EXTERNAL_ACCESSOR = booleanAfter26;
+        IS_INLINE_ACCESSOR = FlagField.booleanAfter(booleanAfter26);
+        BooleanFlagField booleanFirst3 = FlagField.booleanFirst();
+        IS_NEGATED = booleanFirst3;
+        IS_NULL_CHECK_PREDICATE = FlagField.booleanAfter(booleanFirst3);
+        IS_UNSIGNED = FlagField.booleanFirst();
+    }
+
+    public static int getAccessorFlags(boolean z3, ProtoBuf.Visibility visibility, ProtoBuf.Modality modality, boolean z4, boolean z5, boolean z6) {
+        if (visibility == null) {
+            $$$reportNull$$$0(10);
+        }
+        if (modality == null) {
+            $$$reportNull$$$0(11);
+        }
+        return HAS_ANNOTATIONS.toFlags(Boolean.valueOf(z3)) | MODALITY.toFlags(modality) | VISIBILITY.toFlags(visibility) | IS_NOT_DEFAULT.toFlags(Boolean.valueOf(z4)) | IS_EXTERNAL_ACCESSOR.toFlags(Boolean.valueOf(z5)) | IS_INLINE_ACCESSOR.toFlags(Boolean.valueOf(z6));
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/deserialization/NameResolver.java

@@ -0,0 +1,10 @@
+package kotlin.reflect.jvm.internal.impl.metadata.deserialization;
+
+/* loaded from: classes3.dex */
+public interface NameResolver {
+    String getQualifiedClassName(int i);
+
+    String getString(int i);
+
+    boolean isLocalClassName(int i);
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/deserialization/NameResolverImpl.java

@@ -0,0 +1,97 @@
+package kotlin.reflect.jvm.internal.impl.metadata.deserialization;
+
+import com.google.firebase.sessions.settings.RemoteSettings;
+import java.util.LinkedList;
+import java.util.List;
+import kotlin.Triple;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.reflect.jvm.internal.impl.metadata.ProtoBuf;
+
+/* loaded from: classes3.dex */
+public final class NameResolverImpl implements NameResolver {
+    private final ProtoBuf.QualifiedNameTable qualifiedNames;
+    private final ProtoBuf.StringTable strings;
+
+    /* loaded from: classes3.dex */
+    public /* synthetic */ class WhenMappings {
+        public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+        static {
+            int[] iArr = new int[ProtoBuf.QualifiedNameTable.QualifiedName.Kind.values().length];
+            try {
+                iArr[ProtoBuf.QualifiedNameTable.QualifiedName.Kind.CLASS.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                iArr[ProtoBuf.QualifiedNameTable.QualifiedName.Kind.PACKAGE.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                iArr[ProtoBuf.QualifiedNameTable.QualifiedName.Kind.LOCAL.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            $EnumSwitchMapping$0 = iArr;
+        }
+    }
+
+    public NameResolverImpl(ProtoBuf.StringTable strings, ProtoBuf.QualifiedNameTable qualifiedNames) {
+        Intrinsics.checkNotNullParameter(strings, "strings");
+        Intrinsics.checkNotNullParameter(qualifiedNames, "qualifiedNames");
+        this.strings = strings;
+        this.qualifiedNames = qualifiedNames;
+    }
+
+    private final Triple<List<String>, List<String>, Boolean> traverseIds(int i) {
+        LinkedList linkedList = new LinkedList();
+        LinkedList linkedList2 = new LinkedList();
+        boolean z3 = false;
+        while (i != -1) {
+            ProtoBuf.QualifiedNameTable.QualifiedName qualifiedName = this.qualifiedNames.getQualifiedName(i);
+            String string = this.strings.getString(qualifiedName.getShortName());
+            ProtoBuf.QualifiedNameTable.QualifiedName.Kind kind = qualifiedName.getKind();
+            Intrinsics.checkNotNull(kind);
+            int i4 = WhenMappings.$EnumSwitchMapping$0[kind.ordinal()];
+            if (i4 == 1) {
+                linkedList2.addFirst(string);
+            } else if (i4 == 2) {
+                linkedList.addFirst(string);
+            } else if (i4 == 3) {
+                linkedList2.addFirst(string);
+                z3 = true;
+            }
+            i = qualifiedName.getParentQualifiedName();
+        }
+        return new Triple<>(linkedList, linkedList2, Boolean.valueOf(z3));
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.metadata.deserialization.NameResolver
+    public String getQualifiedClassName(int i) {
+        String joinToString$default;
+        String joinToString$default2;
+        Triple<List<String>, List<String>, Boolean> traverseIds = traverseIds(i);
+        List<String> component1 = traverseIds.component1();
+        joinToString$default = CollectionsKt___CollectionsKt.joinToString$default(traverseIds.component2(), ".", null, null, 0, null, null, 62, null);
+        if (component1.isEmpty()) {
+            return joinToString$default;
+        }
+        StringBuilder sb = new StringBuilder();
+        joinToString$default2 = CollectionsKt___CollectionsKt.joinToString$default(component1, RemoteSettings.FORWARD_SLASH_STRING, null, null, 0, null, null, 62, null);
+        sb.append(joinToString$default2);
+        sb.append('/');
+        sb.append(joinToString$default);
+        return sb.toString();
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.metadata.deserialization.NameResolver
+    public String getString(int i) {
+        String string = this.strings.getString(i);
+        Intrinsics.checkNotNullExpressionValue(string, "getString(...)");
+        return string;
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.metadata.deserialization.NameResolver
+    public boolean isLocalClassName(int i) {
+        return traverseIds(i).getThird().booleanValue();
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/deserialization/ProtoBufUtilKt.java

@@ -0,0 +1,28 @@
+package kotlin.reflect.jvm.internal.impl.metadata.deserialization;
+
+import java.util.List;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.reflect.jvm.internal.impl.protobuf.GeneratedMessageLite;
+
+/* loaded from: classes3.dex */
+public final class ProtoBufUtilKt {
+    /* JADX WARN: Multi-variable type inference failed */
+    public static final <M extends GeneratedMessageLite.ExtendableMessage<M>, T> T getExtensionOrNull(GeneratedMessageLite.ExtendableMessage<M> extendableMessage, GeneratedMessageLite.GeneratedExtension<M, T> extension) {
+        Intrinsics.checkNotNullParameter(extendableMessage, "<this>");
+        Intrinsics.checkNotNullParameter(extension, "extension");
+        if (extendableMessage.hasExtension(extension)) {
+            return (T) extendableMessage.getExtension(extension);
+        }
+        return null;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public static final <M extends GeneratedMessageLite.ExtendableMessage<M>, T> T getExtensionOrNull(GeneratedMessageLite.ExtendableMessage<M> extendableMessage, GeneratedMessageLite.GeneratedExtension<M, List<T>> extension, int i) {
+        Intrinsics.checkNotNullParameter(extendableMessage, "<this>");
+        Intrinsics.checkNotNullParameter(extension, "extension");
+        if (i < extendableMessage.getExtensionCount(extension)) {
+            return (T) extendableMessage.getExtension(extension, i);
+        }
+        return null;
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/deserialization/ProtoTypeTableUtilKt.java

@@ -0,0 +1,338 @@
+package kotlin.reflect.jvm.internal.impl.metadata.deserialization;
+
+import java.util.ArrayList;
+import java.util.List;
+import kotlin.collections.CollectionsKt__IterablesKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.reflect.jvm.internal.impl.metadata.ProtoBuf;
+
+@SourceDebugExtension({"SMAP\nprotoTypeTableUtil.kt\nKotlin\n*S Kotlin\n*F\n+ 1 protoTypeTableUtil.kt\norg/jetbrains/kotlin/metadata/deserialization/ProtoTypeTableUtilKt\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n+ 3 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,125:1\n1#2:126\n1549#3:127\n1620#3,3:128\n1549#3:131\n1620#3,3:132\n1549#3:135\n1620#3,3:136\n1549#3:139\n1620#3,3:140\n1549#3:143\n1620#3,3:144\n*S KotlinDebug\n*F\n+ 1 protoTypeTableUtil.kt\norg/jetbrains/kotlin/metadata/deserialization/ProtoTypeTableUtilKt\n*L\n24#1:127\n24#1:128,3\n45#1:131\n45#1:132,3\n118#1:135\n118#1:136,3\n121#1:139\n121#1:140,3\n124#1:143\n124#1:144,3\n*E\n"})
+/* loaded from: classes3.dex */
+public final class ProtoTypeTableUtilKt {
+    public static final ProtoBuf.Type abbreviatedType(ProtoBuf.Type type, TypeTable typeTable) {
+        Intrinsics.checkNotNullParameter(type, "<this>");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        if (type.hasAbbreviatedType()) {
+            return type.getAbbreviatedType();
+        }
+        if (type.hasAbbreviatedTypeId()) {
+            return typeTable.get(type.getAbbreviatedTypeId());
+        }
+        return null;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r0v3 */
+    /* JADX WARN: Type inference failed for: r0v4, types: [java.util.List<kotlin.reflect.jvm.internal.impl.metadata.ProtoBuf$Type>] */
+    /* JADX WARN: Type inference failed for: r0v6, types: [java.util.ArrayList] */
+    /* JADX WARN: Type inference failed for: r0v7 */
+    /* JADX WARN: Type inference failed for: r0v8 */
+    public static final List<ProtoBuf.Type> contextReceiverTypes(ProtoBuf.Class r22, TypeTable typeTable) {
+        int collectionSizeOrDefault;
+        Intrinsics.checkNotNullParameter(r22, "<this>");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        List<ProtoBuf.Type> contextReceiverTypeList = r22.getContextReceiverTypeList();
+        boolean isEmpty = contextReceiverTypeList.isEmpty();
+        ?? r02 = contextReceiverTypeList;
+        if (isEmpty) {
+            r02 = 0;
+        }
+        if (r02 == 0) {
+            List<Integer> contextReceiverTypeIdList = r22.getContextReceiverTypeIdList();
+            Intrinsics.checkNotNullExpressionValue(contextReceiverTypeIdList, "getContextReceiverTypeIdList(...)");
+            List<Integer> list = contextReceiverTypeIdList;
+            collectionSizeOrDefault = CollectionsKt__IterablesKt.collectionSizeOrDefault(list, 10);
+            r02 = new ArrayList(collectionSizeOrDefault);
+            for (Integer num : list) {
+                Intrinsics.checkNotNull(num);
+                r02.add(typeTable.get(num.intValue()));
+            }
+        }
+        return r02;
+    }
+
+    public static final ProtoBuf.Type expandedType(ProtoBuf.TypeAlias typeAlias, TypeTable typeTable) {
+        Intrinsics.checkNotNullParameter(typeAlias, "<this>");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        if (typeAlias.hasExpandedType()) {
+            ProtoBuf.Type expandedType = typeAlias.getExpandedType();
+            Intrinsics.checkNotNullExpressionValue(expandedType, "getExpandedType(...)");
+            return expandedType;
+        }
+        if (typeAlias.hasExpandedTypeId()) {
+            return typeTable.get(typeAlias.getExpandedTypeId());
+        }
+        throw new IllegalStateException("No expandedType in ProtoBuf.TypeAlias");
+    }
+
+    public static final ProtoBuf.Type flexibleUpperBound(ProtoBuf.Type type, TypeTable typeTable) {
+        Intrinsics.checkNotNullParameter(type, "<this>");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        if (type.hasFlexibleUpperBound()) {
+            return type.getFlexibleUpperBound();
+        }
+        if (type.hasFlexibleUpperBoundId()) {
+            return typeTable.get(type.getFlexibleUpperBoundId());
+        }
+        return null;
+    }
+
+    public static final boolean hasReceiver(ProtoBuf.Function function) {
+        Intrinsics.checkNotNullParameter(function, "<this>");
+        return function.hasReceiverType() || function.hasReceiverTypeId();
+    }
+
+    public static final ProtoBuf.Type inlineClassUnderlyingType(ProtoBuf.Class r12, TypeTable typeTable) {
+        Intrinsics.checkNotNullParameter(r12, "<this>");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        if (r12.hasInlineClassUnderlyingType()) {
+            return r12.getInlineClassUnderlyingType();
+        }
+        if (r12.hasInlineClassUnderlyingTypeId()) {
+            return typeTable.get(r12.getInlineClassUnderlyingTypeId());
+        }
+        return null;
+    }
+
+    public static final ProtoBuf.Type outerType(ProtoBuf.Type type, TypeTable typeTable) {
+        Intrinsics.checkNotNullParameter(type, "<this>");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        if (type.hasOuterType()) {
+            return type.getOuterType();
+        }
+        if (type.hasOuterTypeId()) {
+            return typeTable.get(type.getOuterTypeId());
+        }
+        return null;
+    }
+
+    public static final ProtoBuf.Type receiverType(ProtoBuf.Function function, TypeTable typeTable) {
+        Intrinsics.checkNotNullParameter(function, "<this>");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        if (function.hasReceiverType()) {
+            return function.getReceiverType();
+        }
+        if (function.hasReceiverTypeId()) {
+            return typeTable.get(function.getReceiverTypeId());
+        }
+        return null;
+    }
+
+    public static final ProtoBuf.Type returnType(ProtoBuf.Function function, TypeTable typeTable) {
+        Intrinsics.checkNotNullParameter(function, "<this>");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        if (function.hasReturnType()) {
+            ProtoBuf.Type returnType = function.getReturnType();
+            Intrinsics.checkNotNullExpressionValue(returnType, "getReturnType(...)");
+            return returnType;
+        }
+        if (function.hasReturnTypeId()) {
+            return typeTable.get(function.getReturnTypeId());
+        }
+        throw new IllegalStateException("No returnType in ProtoBuf.Function");
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r0v3 */
+    /* JADX WARN: Type inference failed for: r0v4, types: [java.util.List<kotlin.reflect.jvm.internal.impl.metadata.ProtoBuf$Type>] */
+    /* JADX WARN: Type inference failed for: r0v6, types: [java.util.ArrayList] */
+    /* JADX WARN: Type inference failed for: r0v7 */
+    /* JADX WARN: Type inference failed for: r0v8 */
+    public static final List<ProtoBuf.Type> supertypes(ProtoBuf.Class r22, TypeTable typeTable) {
+        int collectionSizeOrDefault;
+        Intrinsics.checkNotNullParameter(r22, "<this>");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        List<ProtoBuf.Type> supertypeList = r22.getSupertypeList();
+        boolean isEmpty = supertypeList.isEmpty();
+        ?? r02 = supertypeList;
+        if (isEmpty) {
+            r02 = 0;
+        }
+        if (r02 == 0) {
+            List<Integer> supertypeIdList = r22.getSupertypeIdList();
+            Intrinsics.checkNotNullExpressionValue(supertypeIdList, "getSupertypeIdList(...)");
+            List<Integer> list = supertypeIdList;
+            collectionSizeOrDefault = CollectionsKt__IterablesKt.collectionSizeOrDefault(list, 10);
+            r02 = new ArrayList(collectionSizeOrDefault);
+            for (Integer num : list) {
+                Intrinsics.checkNotNull(num);
+                r02.add(typeTable.get(num.intValue()));
+            }
+        }
+        return r02;
+    }
+
+    public static final ProtoBuf.Type type(ProtoBuf.Type.Argument argument, TypeTable typeTable) {
+        Intrinsics.checkNotNullParameter(argument, "<this>");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        if (argument.hasType()) {
+            return argument.getType();
+        }
+        if (argument.hasTypeId()) {
+            return typeTable.get(argument.getTypeId());
+        }
+        return null;
+    }
+
+    public static final ProtoBuf.Type underlyingType(ProtoBuf.TypeAlias typeAlias, TypeTable typeTable) {
+        Intrinsics.checkNotNullParameter(typeAlias, "<this>");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        if (typeAlias.hasUnderlyingType()) {
+            ProtoBuf.Type underlyingType = typeAlias.getUnderlyingType();
+            Intrinsics.checkNotNullExpressionValue(underlyingType, "getUnderlyingType(...)");
+            return underlyingType;
+        }
+        if (typeAlias.hasUnderlyingTypeId()) {
+            return typeTable.get(typeAlias.getUnderlyingTypeId());
+        }
+        throw new IllegalStateException("No underlyingType in ProtoBuf.TypeAlias");
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r0v3 */
+    /* JADX WARN: Type inference failed for: r0v4, types: [java.util.List<kotlin.reflect.jvm.internal.impl.metadata.ProtoBuf$Type>] */
+    /* JADX WARN: Type inference failed for: r0v6, types: [java.util.ArrayList] */
+    /* JADX WARN: Type inference failed for: r0v7 */
+    /* JADX WARN: Type inference failed for: r0v8 */
+    public static final List<ProtoBuf.Type> upperBounds(ProtoBuf.TypeParameter typeParameter, TypeTable typeTable) {
+        int collectionSizeOrDefault;
+        Intrinsics.checkNotNullParameter(typeParameter, "<this>");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        List<ProtoBuf.Type> upperBoundList = typeParameter.getUpperBoundList();
+        boolean isEmpty = upperBoundList.isEmpty();
+        ?? r02 = upperBoundList;
+        if (isEmpty) {
+            r02 = 0;
+        }
+        if (r02 == 0) {
+            List<Integer> upperBoundIdList = typeParameter.getUpperBoundIdList();
+            Intrinsics.checkNotNullExpressionValue(upperBoundIdList, "getUpperBoundIdList(...)");
+            List<Integer> list = upperBoundIdList;
+            collectionSizeOrDefault = CollectionsKt__IterablesKt.collectionSizeOrDefault(list, 10);
+            r02 = new ArrayList(collectionSizeOrDefault);
+            for (Integer num : list) {
+                Intrinsics.checkNotNull(num);
+                r02.add(typeTable.get(num.intValue()));
+            }
+        }
+        return r02;
+    }
+
+    public static final ProtoBuf.Type varargElementType(ProtoBuf.ValueParameter valueParameter, TypeTable typeTable) {
+        Intrinsics.checkNotNullParameter(valueParameter, "<this>");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        if (valueParameter.hasVarargElementType()) {
+            return valueParameter.getVarargElementType();
+        }
+        if (valueParameter.hasVarargElementTypeId()) {
+            return typeTable.get(valueParameter.getVarargElementTypeId());
+        }
+        return null;
+    }
+
+    public static final boolean hasReceiver(ProtoBuf.Property property) {
+        Intrinsics.checkNotNullParameter(property, "<this>");
+        return property.hasReceiverType() || property.hasReceiverTypeId();
+    }
+
+    public static final ProtoBuf.Type receiverType(ProtoBuf.Property property, TypeTable typeTable) {
+        Intrinsics.checkNotNullParameter(property, "<this>");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        if (property.hasReceiverType()) {
+            return property.getReceiverType();
+        }
+        if (property.hasReceiverTypeId()) {
+            return typeTable.get(property.getReceiverTypeId());
+        }
+        return null;
+    }
+
+    public static final ProtoBuf.Type type(ProtoBuf.ValueParameter valueParameter, TypeTable typeTable) {
+        Intrinsics.checkNotNullParameter(valueParameter, "<this>");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        if (valueParameter.hasType()) {
+            ProtoBuf.Type type = valueParameter.getType();
+            Intrinsics.checkNotNullExpressionValue(type, "getType(...)");
+            return type;
+        }
+        if (valueParameter.hasTypeId()) {
+            return typeTable.get(valueParameter.getTypeId());
+        }
+        throw new IllegalStateException("No type in ProtoBuf.ValueParameter");
+    }
+
+    public static final ProtoBuf.Type returnType(ProtoBuf.Property property, TypeTable typeTable) {
+        Intrinsics.checkNotNullParameter(property, "<this>");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        if (property.hasReturnType()) {
+            ProtoBuf.Type returnType = property.getReturnType();
+            Intrinsics.checkNotNullExpressionValue(returnType, "getReturnType(...)");
+            return returnType;
+        }
+        if (property.hasReturnTypeId()) {
+            return typeTable.get(property.getReturnTypeId());
+        }
+        throw new IllegalStateException("No returnType in ProtoBuf.Property");
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r0v3 */
+    /* JADX WARN: Type inference failed for: r0v4, types: [java.util.List<kotlin.reflect.jvm.internal.impl.metadata.ProtoBuf$Type>] */
+    /* JADX WARN: Type inference failed for: r0v6, types: [java.util.ArrayList] */
+    /* JADX WARN: Type inference failed for: r0v7 */
+    /* JADX WARN: Type inference failed for: r0v8 */
+    public static final List<ProtoBuf.Type> contextReceiverTypes(ProtoBuf.Function function, TypeTable typeTable) {
+        int collectionSizeOrDefault;
+        Intrinsics.checkNotNullParameter(function, "<this>");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        List<ProtoBuf.Type> contextReceiverTypeList = function.getContextReceiverTypeList();
+        boolean isEmpty = contextReceiverTypeList.isEmpty();
+        ?? r02 = contextReceiverTypeList;
+        if (isEmpty) {
+            r02 = 0;
+        }
+        if (r02 == 0) {
+            List<Integer> contextReceiverTypeIdList = function.getContextReceiverTypeIdList();
+            Intrinsics.checkNotNullExpressionValue(contextReceiverTypeIdList, "getContextReceiverTypeIdList(...)");
+            List<Integer> list = contextReceiverTypeIdList;
+            collectionSizeOrDefault = CollectionsKt__IterablesKt.collectionSizeOrDefault(list, 10);
+            r02 = new ArrayList(collectionSizeOrDefault);
+            for (Integer num : list) {
+                Intrinsics.checkNotNull(num);
+                r02.add(typeTable.get(num.intValue()));
+            }
+        }
+        return r02;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r0v3 */
+    /* JADX WARN: Type inference failed for: r0v4, types: [java.util.List<kotlin.reflect.jvm.internal.impl.metadata.ProtoBuf$Type>] */
+    /* JADX WARN: Type inference failed for: r0v6, types: [java.util.ArrayList] */
+    /* JADX WARN: Type inference failed for: r0v7 */
+    /* JADX WARN: Type inference failed for: r0v8 */
+    public static final List<ProtoBuf.Type> contextReceiverTypes(ProtoBuf.Property property, TypeTable typeTable) {
+        int collectionSizeOrDefault;
+        Intrinsics.checkNotNullParameter(property, "<this>");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        List<ProtoBuf.Type> contextReceiverTypeList = property.getContextReceiverTypeList();
+        boolean isEmpty = contextReceiverTypeList.isEmpty();
+        ?? r02 = contextReceiverTypeList;
+        if (isEmpty) {
+            r02 = 0;
+        }
+        if (r02 == 0) {
+            List<Integer> contextReceiverTypeIdList = property.getContextReceiverTypeIdList();
+            Intrinsics.checkNotNullExpressionValue(contextReceiverTypeIdList, "getContextReceiverTypeIdList(...)");
+            List<Integer> list = contextReceiverTypeIdList;
+            collectionSizeOrDefault = CollectionsKt__IterablesKt.collectionSizeOrDefault(list, 10);
+            r02 = new ArrayList(collectionSizeOrDefault);
+            for (Integer num : list) {
+                Intrinsics.checkNotNull(num);
+                r02.add(typeTable.get(num.intValue()));
+            }
+        }
+        return r02;
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/deserialization/TypeTable.java

@@ -0,0 +1,49 @@
+package kotlin.reflect.jvm.internal.impl.metadata.deserialization;
+
+import java.util.ArrayList;
+import java.util.List;
+import kotlin.collections.CollectionsKt;
+import kotlin.collections.CollectionsKt__IterablesKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.reflect.jvm.internal.impl.metadata.ProtoBuf;
+
+@SourceDebugExtension({"SMAP\nTypeTable.kt\nKotlin\n*S Kotlin\n*F\n+ 1 TypeTable.kt\norg/jetbrains/kotlin/metadata/deserialization/TypeTable\n+ 2 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,36:1\n1559#2:37\n1590#2,4:38\n*S KotlinDebug\n*F\n+ 1 TypeTable.kt\norg/jetbrains/kotlin/metadata/deserialization/TypeTable\n*L\n26#1:37\n26#1:38,4\n*E\n"})
+/* loaded from: classes3.dex */
+public final class TypeTable {
+    private final List<ProtoBuf.Type> types;
+
+    public TypeTable(ProtoBuf.TypeTable typeTable) {
+        int collectionSizeOrDefault;
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        List<ProtoBuf.Type> typeList = typeTable.getTypeList();
+        if (typeTable.hasFirstNullable()) {
+            int firstNullable = typeTable.getFirstNullable();
+            List<ProtoBuf.Type> typeList2 = typeTable.getTypeList();
+            Intrinsics.checkNotNullExpressionValue(typeList2, "getTypeList(...)");
+            List<ProtoBuf.Type> list = typeList2;
+            collectionSizeOrDefault = CollectionsKt__IterablesKt.collectionSizeOrDefault(list, 10);
+            ArrayList arrayList = new ArrayList(collectionSizeOrDefault);
+            int i = 0;
+            for (Object obj : list) {
+                int i4 = i + 1;
+                if (i < 0) {
+                    CollectionsKt.throwIndexOverflow();
+                }
+                ProtoBuf.Type type = (ProtoBuf.Type) obj;
+                if (i >= firstNullable) {
+                    type = type.toBuilder().setNullable(true).build();
+                }
+                arrayList.add(type);
+                i = i4;
+            }
+            typeList = arrayList;
+        }
+        Intrinsics.checkNotNullExpressionValue(typeList, "run(...)");
+        this.types = typeList;
+    }
+
+    public final ProtoBuf.Type get(int i) {
+        return this.types.get(i);
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/deserialization/VersionRequirementTable.java

@@ -0,0 +1,46 @@
+package kotlin.reflect.jvm.internal.impl.metadata.deserialization;
+
+import java.util.List;
+import kotlin.collections.CollectionsKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.reflect.jvm.internal.impl.metadata.ProtoBuf;
+
+/* loaded from: classes3.dex */
+public final class VersionRequirementTable {
+    public static final Companion Companion = new Companion(null);
+    private static final VersionRequirementTable EMPTY = new VersionRequirementTable(CollectionsKt.emptyList());
+    private final List<ProtoBuf.VersionRequirement> infos;
+
+    /* loaded from: classes3.dex */
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public final VersionRequirementTable create(ProtoBuf.VersionRequirementTable table) {
+            Intrinsics.checkNotNullParameter(table, "table");
+            if (table.getRequirementCount() == 0) {
+                return getEMPTY();
+            }
+            List<ProtoBuf.VersionRequirement> requirementList = table.getRequirementList();
+            Intrinsics.checkNotNullExpressionValue(requirementList, "getRequirementList(...)");
+            return new VersionRequirementTable(requirementList, null);
+        }
+
+        public final VersionRequirementTable getEMPTY() {
+            return VersionRequirementTable.EMPTY;
+        }
+
+        private Companion() {
+        }
+    }
+
+    public /* synthetic */ VersionRequirementTable(List list, DefaultConstructorMarker defaultConstructorMarker) {
+        this(list);
+    }
+
+    private VersionRequirementTable(List<ProtoBuf.VersionRequirement> list) {
+        this.infos = list;
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/deserialization/VersionSpecificBehaviorKt.java

@@ -0,0 +1,16 @@
+package kotlin.reflect.jvm.internal.impl.metadata.deserialization;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public final class VersionSpecificBehaviorKt {
+    public static final boolean isKotlin1Dot4OrLater(BinaryVersion version) {
+        Intrinsics.checkNotNullParameter(version, "version");
+        return (version.getMajor() == 1 && version.getMinor() >= 4) || version.getMajor() > 1;
+    }
+
+    public static final boolean isVersionRequirementTableWrittenCorrectly(BinaryVersion version) {
+        Intrinsics.checkNotNullParameter(version, "version");
+        return isKotlin1Dot4OrLater(version);
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/jvm/deserialization/BitEncoding.java

@@ -0,0 +1,176 @@
+package kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization;
+
+import com.google.firebase.messaging.Constants;
+import kotlin.UByte;
+import kotlinx.coroutines.scheduling.WorkQueueKt;
+
+/* loaded from: classes3.dex */
+public class BitEncoding {
+    static final /* synthetic */ boolean $assertionsDisabled = false;
+    private static final boolean FORCE_8TO7_ENCODING;
+
+    private static /* synthetic */ void $$$reportNull$$$0(int i) {
+        String str = (i == 1 || i == 3 || i == 6 || i == 8 || i == 10 || i == 12 || i == 14) ? "@NotNull method %s.%s must not return null" : "Argument for @NotNull parameter '%s' of %s.%s must not be null";
+        Object[] objArr = new Object[(i == 1 || i == 3 || i == 6 || i == 8 || i == 10 || i == 12 || i == 14) ? 2 : 3];
+        if (i == 1 || i == 3 || i == 6 || i == 8 || i == 10 || i == 12 || i == 14) {
+            objArr[0] = "kotlin/reflect/jvm/internal/impl/metadata/jvm/deserialization/BitEncoding";
+        } else {
+            objArr[0] = Constants.ScionAnalytics.MessageType.DATA_MESSAGE;
+        }
+        if (i == 1) {
+            objArr[1] = "encodeBytes";
+        } else if (i == 3) {
+            objArr[1] = "encode8to7";
+        } else if (i == 6) {
+            objArr[1] = "splitBytesToStringArray";
+        } else if (i == 8) {
+            objArr[1] = "decodeBytes";
+        } else if (i == 10) {
+            objArr[1] = "dropMarker";
+        } else if (i == 12) {
+            objArr[1] = "combineStringArrayIntoBytes";
+        } else if (i != 14) {
+            objArr[1] = "kotlin/reflect/jvm/internal/impl/metadata/jvm/deserialization/BitEncoding";
+        } else {
+            objArr[1] = "decode7to8";
+        }
+        switch (i) {
+            case 1:
+            case 3:
+            case 6:
+            case 8:
+            case 10:
+            case 12:
+            case 14:
+                break;
+            case 2:
+                objArr[2] = "encode8to7";
+                break;
+            case 4:
+                objArr[2] = "addModuloByte";
+                break;
+            case 5:
+                objArr[2] = "splitBytesToStringArray";
+                break;
+            case 7:
+                objArr[2] = "decodeBytes";
+                break;
+            case 9:
+                objArr[2] = "dropMarker";
+                break;
+            case 11:
+                objArr[2] = "combineStringArrayIntoBytes";
+                break;
+            case 13:
+                objArr[2] = "decode7to8";
+                break;
+            default:
+                objArr[2] = "encodeBytes";
+                break;
+        }
+        String format = String.format(str, objArr);
+        if (i != 1 && i != 3 && i != 6 && i != 8 && i != 10 && i != 12 && i != 14) {
+            throw new IllegalArgumentException(format);
+        }
+        throw new IllegalStateException(format);
+    }
+
+    static {
+        String str;
+        try {
+            str = System.getProperty("kotlin.jvm.serialization.use8to7");
+        } catch (SecurityException unused) {
+            str = null;
+        }
+        FORCE_8TO7_ENCODING = "true".equals(str);
+    }
+
+    private BitEncoding() {
+    }
+
+    private static void addModuloByte(byte[] bArr, int i) {
+        if (bArr == null) {
+            $$$reportNull$$$0(4);
+        }
+        int length = bArr.length;
+        for (int i4 = 0; i4 < length; i4++) {
+            bArr[i4] = (byte) ((bArr[i4] + i) & WorkQueueKt.MASK);
+        }
+    }
+
+    private static byte[] combineStringArrayIntoBytes(String[] strArr) {
+        if (strArr == null) {
+            $$$reportNull$$$0(11);
+        }
+        int i = 0;
+        for (String str : strArr) {
+            i += str.length();
+        }
+        byte[] bArr = new byte[i];
+        int i4 = 0;
+        for (String str2 : strArr) {
+            int length = str2.length();
+            int i5 = 0;
+            while (i5 < length) {
+                bArr[i4] = (byte) str2.charAt(i5);
+                i5++;
+                i4++;
+            }
+        }
+        return bArr;
+    }
+
+    private static byte[] decode7to8(byte[] bArr) {
+        if (bArr == null) {
+            $$$reportNull$$$0(13);
+        }
+        int length = (bArr.length * 7) / 8;
+        byte[] bArr2 = new byte[length];
+        int i = 0;
+        int i4 = 0;
+        for (int i5 = 0; i5 < length; i5++) {
+            int i6 = i + 1;
+            int i7 = i4 + 1;
+            bArr2[i5] = (byte) (((bArr[i] & UByte.MAX_VALUE) >>> i4) + ((bArr[i6] & ((1 << i7) - 1)) << (7 - i4)));
+            if (i4 == 6) {
+                i += 2;
+                i4 = 0;
+            } else {
+                i = i6;
+                i4 = i7;
+            }
+        }
+        return bArr2;
+    }
+
+    public static byte[] decodeBytes(String[] strArr) {
+        if (strArr == null) {
+            $$$reportNull$$$0(7);
+        }
+        if (strArr.length > 0 && !strArr[0].isEmpty()) {
+            char charAt = strArr[0].charAt(0);
+            if (charAt == 0) {
+                byte[] stringsToBytes = UtfEncodingKt.stringsToBytes(dropMarker(strArr));
+                if (stringsToBytes == null) {
+                    $$$reportNull$$$0(8);
+                }
+                return stringsToBytes;
+            }
+            if (charAt == 65535) {
+                strArr = dropMarker(strArr);
+            }
+        }
+        byte[] combineStringArrayIntoBytes = combineStringArrayIntoBytes(strArr);
+        addModuloByte(combineStringArrayIntoBytes, WorkQueueKt.MASK);
+        return decode7to8(combineStringArrayIntoBytes);
+    }
+
+    private static String[] dropMarker(String[] strArr) {
+        if (strArr == null) {
+            $$$reportNull$$$0(9);
+        }
+        String[] strArr2 = (String[]) strArr.clone();
+        strArr2[0] = strArr2[0].substring(1);
+        return strArr2;
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/jvm/deserialization/ClassMapperLite.java

@@ -0,0 +1,104 @@
+package kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization;
+
+import C.w;
+import com.google.android.gms.measurement.internal.a;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import kotlin.collections.CollectionsKt;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.internal.ProgressionUtilKt;
+import kotlin.jvm.JvmStatic;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.StringsKt__StringsJVMKt;
+import kotlin.text.Typography;
+
+/* loaded from: classes3.dex */
+public final class ClassMapperLite {
+    public static final ClassMapperLite INSTANCE = new ClassMapperLite();
+
+    /* renamed from: kotlin, reason: collision with root package name */
+    private static final String f7135kotlin;
+    private static final Map<String, String> map;
+
+    static {
+        String joinToString$default;
+        joinToString$default = CollectionsKt___CollectionsKt.joinToString$default(CollectionsKt.listOf((Object[]) new Character[]{'k', 'o', 't', 'l', 'i', 'n'}), "", null, null, 0, null, null, 62, null);
+        f7135kotlin = joinToString$default;
+        LinkedHashMap linkedHashMap = new LinkedHashMap();
+        List listOf = CollectionsKt.listOf((Object[]) new String[]{"Boolean", "Z", "Char", "C", "Byte", "B", "Short", "S", "Int", "I", "Float", "F", "Long", "J", "Double", "D"});
+        int progressionLastElement = ProgressionUtilKt.getProgressionLastElement(0, listOf.size() - 1, 2);
+        if (progressionLastElement >= 0) {
+            int i = 0;
+            while (true) {
+                StringBuilder sb = new StringBuilder();
+                String str = f7135kotlin;
+                sb.append(str);
+                sb.append('/');
+                sb.append((String) listOf.get(i));
+                int i4 = i + 1;
+                linkedHashMap.put(sb.toString(), listOf.get(i4));
+                StringBuilder sb2 = new StringBuilder();
+                sb2.append(str);
+                sb2.append('/');
+                linkedHashMap.put(w.r(sb2, (String) listOf.get(i), "Array"), "[" + ((String) listOf.get(i4)));
+                if (i == progressionLastElement) {
+                    break;
+                } else {
+                    i += 2;
+                }
+            }
+        }
+        linkedHashMap.put(f7135kotlin + "/Unit", "V");
+        map$lambda$0$add(linkedHashMap, "Any", "java/lang/Object");
+        map$lambda$0$add(linkedHashMap, "Nothing", "java/lang/Void");
+        map$lambda$0$add(linkedHashMap, "Annotation", "java/lang/annotation/Annotation");
+        for (String str2 : CollectionsKt.listOf((Object[]) new String[]{"String", "CharSequence", "Throwable", "Cloneable", "Number", "Comparable", "Enum"})) {
+            map$lambda$0$add(linkedHashMap, str2, w.z("java/lang/", str2));
+        }
+        for (String str3 : CollectionsKt.listOf((Object[]) new String[]{"Iterator", "Collection", "List", "Set", "Map", "ListIterator"})) {
+            map$lambda$0$add(linkedHashMap, w.z("collections/", str3), w.z("java/util/", str3));
+            map$lambda$0$add(linkedHashMap, w.z("collections/Mutable", str3), w.z("java/util/", str3));
+        }
+        map$lambda$0$add(linkedHashMap, "collections/Iterable", "java/lang/Iterable");
+        map$lambda$0$add(linkedHashMap, "collections/MutableIterable", "java/lang/Iterable");
+        map$lambda$0$add(linkedHashMap, "collections/Map.Entry", "java/util/Map$Entry");
+        map$lambda$0$add(linkedHashMap, "collections/MutableMap.MutableEntry", "java/util/Map$Entry");
+        for (int i5 = 0; i5 < 23; i5++) {
+            String l4 = a.l(i5, "Function");
+            StringBuilder sb3 = new StringBuilder();
+            String str4 = f7135kotlin;
+            sb3.append(str4);
+            sb3.append("/jvm/functions/Function");
+            sb3.append(i5);
+            map$lambda$0$add(linkedHashMap, l4, sb3.toString());
+            map$lambda$0$add(linkedHashMap, a.l(i5, "reflect/KFunction"), w.n(str4, "/reflect/KFunction"));
+        }
+        for (String str5 : CollectionsKt.listOf((Object[]) new String[]{"Char", "Byte", "Short", "Int", "Float", "Long", "Double", "String", "Enum"})) {
+            map$lambda$0$add(linkedHashMap, w.n(str5, ".Companion"), f7135kotlin + "/jvm/internal/" + str5 + "CompanionObject");
+        }
+        map = linkedHashMap;
+    }
+
+    private ClassMapperLite() {
+    }
+
+    private static final void map$lambda$0$add(Map<String, String> map2, String str, String str2) {
+        map2.put(f7135kotlin + '/' + str, "L" + str2 + ';');
+    }
+
+    @JvmStatic
+    public static final String mapClass(String classId) {
+        String replace$default;
+        Intrinsics.checkNotNullParameter(classId, "classId");
+        String str = map.get(classId);
+        if (str != null) {
+            return str;
+        }
+        StringBuilder sb = new StringBuilder("L");
+        replace$default = StringsKt__StringsJVMKt.replace$default(classId, '.', Typography.dollar, false, 4, (Object) null);
+        sb.append(replace$default);
+        sb.append(';');
+        return sb.toString();
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/jvm/deserialization/JvmFlags.java

@@ -0,0 +1,24 @@
+package kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization;
+
+import kotlin.reflect.jvm.internal.impl.metadata.deserialization.Flags;
+
+/* loaded from: classes3.dex */
+public final class JvmFlags {
+    private static final Flags.BooleanFlagField IS_COMPILED_IN_COMPATIBILITY_MODE;
+    private static final Flags.BooleanFlagField IS_COMPILED_IN_JVM_DEFAULT_MODE;
+    public static final JvmFlags INSTANCE = new JvmFlags();
+    private static final Flags.BooleanFlagField IS_MOVED_FROM_INTERFACE_COMPANION = Flags.FlagField.booleanFirst();
+
+    static {
+        Flags.BooleanFlagField booleanFirst = Flags.FlagField.booleanFirst();
+        IS_COMPILED_IN_JVM_DEFAULT_MODE = booleanFirst;
+        IS_COMPILED_IN_COMPATIBILITY_MODE = Flags.FlagField.booleanAfter(booleanFirst);
+    }
+
+    private JvmFlags() {
+    }
+
+    public final Flags.BooleanFlagField getIS_MOVED_FROM_INTERFACE_COMPANION() {
+        return IS_MOVED_FROM_INTERFACE_COMPANION;
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/jvm/deserialization/JvmMemberSignature.java

@@ -0,0 +1,139 @@
+package kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization;
+
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public abstract class JvmMemberSignature {
+
+    /* loaded from: classes3.dex */
+    public static final class Field extends JvmMemberSignature {
+        private final String desc;
+        private final String name;
+
+        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+        public Field(String name, String desc) {
+            super(null);
+            Intrinsics.checkNotNullParameter(name, "name");
+            Intrinsics.checkNotNullParameter(desc, "desc");
+            this.name = name;
+            this.desc = desc;
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization.JvmMemberSignature
+        public String asString() {
+            return getName() + ':' + getDesc();
+        }
+
+        public final String component1() {
+            return this.name;
+        }
+
+        public final String component2() {
+            return this.desc;
+        }
+
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (!(obj instanceof Field)) {
+                return false;
+            }
+            Field field = (Field) obj;
+            return Intrinsics.areEqual(this.name, field.name) && Intrinsics.areEqual(this.desc, field.desc);
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization.JvmMemberSignature
+        public String getDesc() {
+            return this.desc;
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization.JvmMemberSignature
+        public String getName() {
+            return this.name;
+        }
+
+        public int hashCode() {
+            return this.desc.hashCode() + (this.name.hashCode() * 31);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class Method extends JvmMemberSignature {
+        private final String desc;
+        private final String name;
+
+        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+        public Method(String name, String desc) {
+            super(null);
+            Intrinsics.checkNotNullParameter(name, "name");
+            Intrinsics.checkNotNullParameter(desc, "desc");
+            this.name = name;
+            this.desc = desc;
+        }
+
+        public static /* synthetic */ Method copy$default(Method method, String str, String str2, int i, Object obj) {
+            if ((i & 1) != 0) {
+                str = method.name;
+            }
+            if ((i & 2) != 0) {
+                str2 = method.desc;
+            }
+            return method.copy(str, str2);
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization.JvmMemberSignature
+        public String asString() {
+            return getName() + getDesc();
+        }
+
+        public final Method copy(String name, String desc) {
+            Intrinsics.checkNotNullParameter(name, "name");
+            Intrinsics.checkNotNullParameter(desc, "desc");
+            return new Method(name, desc);
+        }
+
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (!(obj instanceof Method)) {
+                return false;
+            }
+            Method method = (Method) obj;
+            return Intrinsics.areEqual(this.name, method.name) && Intrinsics.areEqual(this.desc, method.desc);
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization.JvmMemberSignature
+        public String getDesc() {
+            return this.desc;
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization.JvmMemberSignature
+        public String getName() {
+            return this.name;
+        }
+
+        public int hashCode() {
+            return this.desc.hashCode() + (this.name.hashCode() * 31);
+        }
+    }
+
+    public /* synthetic */ JvmMemberSignature(DefaultConstructorMarker defaultConstructorMarker) {
+        this();
+    }
+
+    public abstract String asString();
+
+    public abstract String getDesc();
+
+    public abstract String getName();
+
+    public final String toString() {
+        return asString();
+    }
+
+    private JvmMemberSignature() {
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/jvm/deserialization/JvmMetadataVersion.java

@@ -0,0 +1,90 @@
+package kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization;
+
+import java.util.Arrays;
+import kotlin.jvm.JvmField;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.reflect.jvm.internal.impl.metadata.deserialization.BinaryVersion;
+
+/* loaded from: classes3.dex */
+public final class JvmMetadataVersion extends BinaryVersion {
+    public static final Companion Companion = new Companion(null);
+
+    @JvmField
+    public static final JvmMetadataVersion INSTANCE;
+
+    @JvmField
+    public static final JvmMetadataVersion INSTANCE_NEXT;
+
+    @JvmField
+    public static final JvmMetadataVersion INVALID_VERSION;
+    private final boolean isStrictSemantics;
+
+    /* loaded from: classes3.dex */
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+
+    static {
+        JvmMetadataVersion jvmMetadataVersion = new JvmMetadataVersion(1, 9, 0);
+        INSTANCE = jvmMetadataVersion;
+        INSTANCE_NEXT = jvmMetadataVersion.next();
+        INVALID_VERSION = new JvmMetadataVersion(new int[0]);
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public JvmMetadataVersion(int[] versionArray, boolean z3) {
+        super(Arrays.copyOf(versionArray, versionArray.length));
+        Intrinsics.checkNotNullParameter(versionArray, "versionArray");
+        this.isStrictSemantics = z3;
+    }
+
+    private final boolean isCompatibleInternal(JvmMetadataVersion jvmMetadataVersion) {
+        if ((getMajor() == 1 && getMinor() == 0) || getMajor() == 0) {
+            return false;
+        }
+        return !newerThan(jvmMetadataVersion);
+    }
+
+    private final boolean newerThan(JvmMetadataVersion jvmMetadataVersion) {
+        if (getMajor() > jvmMetadataVersion.getMajor()) {
+            return true;
+        }
+        return getMajor() >= jvmMetadataVersion.getMajor() && getMinor() > jvmMetadataVersion.getMinor();
+    }
+
+    public final boolean isCompatible(JvmMetadataVersion metadataVersionFromLanguageVersion) {
+        Intrinsics.checkNotNullParameter(metadataVersionFromLanguageVersion, "metadataVersionFromLanguageVersion");
+        if (getMajor() == 2 && getMinor() == 0) {
+            JvmMetadataVersion jvmMetadataVersion = INSTANCE;
+            if (jvmMetadataVersion.getMajor() == 1 && jvmMetadataVersion.getMinor() == 8) {
+                return true;
+            }
+        }
+        return isCompatibleInternal(metadataVersionFromLanguageVersion.lastSupportedVersionWithThisLanguageVersion(this.isStrictSemantics));
+    }
+
+    public final boolean isStrictSemantics() {
+        return this.isStrictSemantics;
+    }
+
+    public final JvmMetadataVersion lastSupportedVersionWithThisLanguageVersion(boolean z3) {
+        JvmMetadataVersion jvmMetadataVersion = z3 ? INSTANCE : INSTANCE_NEXT;
+        return jvmMetadataVersion.newerThan(this) ? jvmMetadataVersion : this;
+    }
+
+    public final JvmMetadataVersion next() {
+        return (getMajor() == 1 && getMinor() == 9) ? new JvmMetadataVersion(2, 0, 0) : new JvmMetadataVersion(getMajor(), getMinor() + 1, 0);
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public JvmMetadataVersion(int... numbers) {
+        this(numbers, false);
+        Intrinsics.checkNotNullParameter(numbers, "numbers");
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/jvm/deserialization/JvmNameResolver.java

@@ -0,0 +1,43 @@
+package kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization;
+
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.reflect.jvm.internal.impl.metadata.jvm.JvmProtoBuf;
+
+@SourceDebugExtension({"SMAP\nJvmNameResolver.kt\nKotlin\n*S Kotlin\n*F\n+ 1 JvmNameResolver.kt\norg/jetbrains/kotlin/metadata/jvm/deserialization/JvmNameResolver\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,34:1\n1#2:35\n*E\n"})
+/* loaded from: classes3.dex */
+public final class JvmNameResolver extends JvmNameResolverBase {
+    private final JvmProtoBuf.StringTableTypes types;
+
+    /* JADX WARN: Illegal instructions before constructor call */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public JvmNameResolver(kotlin.reflect.jvm.internal.impl.metadata.jvm.JvmProtoBuf.StringTableTypes r4, java.lang.String[] r5) {
+        /*
+            r3 = this;
+            java.lang.String r0 = "types"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r4, r0)
+            java.lang.String r0 = "strings"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r5, r0)
+            java.util.List r0 = r4.getLocalNameList()
+            boolean r1 = r0.isEmpty()
+            if (r1 == 0) goto L19
+            java.util.Set r0 = kotlin.collections.SetsKt.emptySet()
+            goto L22
+        L19:
+            kotlin.jvm.internal.Intrinsics.checkNotNull(r0)
+            java.lang.Iterable r0 = (java.lang.Iterable) r0
+            java.util.Set r0 = kotlin.collections.CollectionsKt.toSet(r0)
+        L22:
+            java.util.List r1 = r4.getRecordList()
+            java.lang.String r2 = "getRecordList(...)"
+            kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r1, r2)
+            java.util.List r1 = kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization.JvmNameResolverKt.toExpandedRecordsList(r1)
+            r3.<init>(r5, r0, r1)
+            r3.types = r4
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization.JvmNameResolver.<init>(kotlin.reflect.jvm.internal.impl.metadata.jvm.JvmProtoBuf$StringTableTypes, java.lang.String[]):void");
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/jvm/deserialization/JvmNameResolverBase.java

@@ -0,0 +1,163 @@
+package kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization;
+
+import C.w;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import kotlin.collections.CollectionsKt;
+import kotlin.collections.CollectionsKt__IterablesKt;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.collections.IndexedValue;
+import kotlin.collections.MapsKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.ranges.RangesKt;
+import kotlin.reflect.jvm.internal.impl.metadata.deserialization.NameResolver;
+import kotlin.reflect.jvm.internal.impl.metadata.jvm.JvmProtoBuf;
+import kotlin.text.StringsKt__StringsJVMKt;
+import kotlin.text.Typography;
+
+@SourceDebugExtension({"SMAP\nJvmNameResolverBase.kt\nKotlin\n*S Kotlin\n*F\n+ 1 JvmNameResolverBase.kt\norg/jetbrains/kotlin/metadata/jvm/deserialization/JvmNameResolverBase\n+ 2 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,106:1\n1208#2,2:107\n1238#2,4:109\n*S KotlinDebug\n*F\n+ 1 JvmNameResolverBase.kt\norg/jetbrains/kotlin/metadata/jvm/deserialization/JvmNameResolverBase\n*L\n101#1:107,2\n101#1:109,4\n*E\n"})
+/* loaded from: classes3.dex */
+public class JvmNameResolverBase implements NameResolver {
+    public static final Companion Companion = new Companion(null);
+    private static final List<String> PREDEFINED_STRINGS;
+    private static final Map<String, Integer> PREDEFINED_STRINGS_MAP;
+
+    /* renamed from: kotlin, reason: collision with root package name */
+    private static final String f7136kotlin;
+    private final Set<Integer> localNameIndices;
+    private final List<JvmProtoBuf.StringTableTypes.Record> records;
+    private final String[] strings;
+
+    /* loaded from: classes3.dex */
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public /* synthetic */ class WhenMappings {
+        public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+        static {
+            int[] iArr = new int[JvmProtoBuf.StringTableTypes.Record.Operation.values().length];
+            try {
+                iArr[JvmProtoBuf.StringTableTypes.Record.Operation.NONE.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                iArr[JvmProtoBuf.StringTableTypes.Record.Operation.INTERNAL_TO_CLASS_ID.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                iArr[JvmProtoBuf.StringTableTypes.Record.Operation.DESC_TO_CLASS_ID.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            $EnumSwitchMapping$0 = iArr;
+        }
+    }
+
+    static {
+        String joinToString$default;
+        int collectionSizeOrDefault;
+        joinToString$default = CollectionsKt___CollectionsKt.joinToString$default(CollectionsKt.listOf((Object[]) new Character[]{'k', 'o', 't', 'l', 'i', 'n'}), "", null, null, 0, null, null, 62, null);
+        f7136kotlin = joinToString$default;
+        List<String> listOf = CollectionsKt.listOf((Object[]) new String[]{w.n(joinToString$default, "/Any"), w.n(joinToString$default, "/Nothing"), w.n(joinToString$default, "/Unit"), w.n(joinToString$default, "/Throwable"), w.n(joinToString$default, "/Number"), w.n(joinToString$default, "/Byte"), w.n(joinToString$default, "/Double"), w.n(joinToString$default, "/Float"), w.n(joinToString$default, "/Int"), w.n(joinToString$default, "/Long"), w.n(joinToString$default, "/Short"), w.n(joinToString$default, "/Boolean"), w.n(joinToString$default, "/Char"), w.n(joinToString$default, "/CharSequence"), w.n(joinToString$default, "/String"), w.n(joinToString$default, "/Comparable"), w.n(joinToString$default, "/Enum"), w.n(joinToString$default, "/Array"), w.n(joinToString$default, "/ByteArray"), w.n(joinToString$default, "/DoubleArray"), w.n(joinToString$default, "/FloatArray"), w.n(joinToString$default, "/IntArray"), w.n(joinToString$default, "/LongArray"), w.n(joinToString$default, "/ShortArray"), w.n(joinToString$default, "/BooleanArray"), w.n(joinToString$default, "/CharArray"), w.n(joinToString$default, "/Cloneable"), w.n(joinToString$default, "/Annotation"), w.n(joinToString$default, "/collections/Iterable"), w.n(joinToString$default, "/collections/MutableIterable"), w.n(joinToString$default, "/collections/Collection"), w.n(joinToString$default, "/collections/MutableCollection"), w.n(joinToString$default, "/collections/List"), w.n(joinToString$default, "/collections/MutableList"), w.n(joinToString$default, "/collections/Set"), w.n(joinToString$default, "/collections/MutableSet"), w.n(joinToString$default, "/collections/Map"), w.n(joinToString$default, "/collections/MutableMap"), w.n(joinToString$default, "/collections/Map.Entry"), w.n(joinToString$default, "/collections/MutableMap.MutableEntry"), w.n(joinToString$default, "/collections/Iterator"), w.n(joinToString$default, "/collections/MutableIterator"), w.n(joinToString$default, "/collections/ListIterator"), w.n(joinToString$default, "/collections/MutableListIterator")});
+        PREDEFINED_STRINGS = listOf;
+        Iterable<IndexedValue> withIndex = CollectionsKt.withIndex(listOf);
+        collectionSizeOrDefault = CollectionsKt__IterablesKt.collectionSizeOrDefault(withIndex, 10);
+        LinkedHashMap linkedHashMap = new LinkedHashMap(RangesKt.coerceAtLeast(MapsKt.mapCapacity(collectionSizeOrDefault), 16));
+        for (IndexedValue indexedValue : withIndex) {
+            linkedHashMap.put((String) indexedValue.getValue(), Integer.valueOf(indexedValue.getIndex()));
+        }
+        PREDEFINED_STRINGS_MAP = linkedHashMap;
+    }
+
+    public JvmNameResolverBase(String[] strings, Set<Integer> localNameIndices, List<JvmProtoBuf.StringTableTypes.Record> records) {
+        Intrinsics.checkNotNullParameter(strings, "strings");
+        Intrinsics.checkNotNullParameter(localNameIndices, "localNameIndices");
+        Intrinsics.checkNotNullParameter(records, "records");
+        this.strings = strings;
+        this.localNameIndices = localNameIndices;
+        this.records = records;
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.metadata.deserialization.NameResolver
+    public String getQualifiedClassName(int i) {
+        return getString(i);
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.metadata.deserialization.NameResolver
+    public String getString(int i) {
+        String str;
+        JvmProtoBuf.StringTableTypes.Record record = this.records.get(i);
+        if (record.hasString()) {
+            str = record.getString();
+        } else {
+            if (record.hasPredefinedIndex()) {
+                List<String> list = PREDEFINED_STRINGS;
+                int size = list.size();
+                int predefinedIndex = record.getPredefinedIndex();
+                if (predefinedIndex >= 0 && predefinedIndex < size) {
+                    str = list.get(record.getPredefinedIndex());
+                }
+            }
+            str = this.strings[i];
+        }
+        if (record.getSubstringIndexCount() >= 2) {
+            List<Integer> substringIndexList = record.getSubstringIndexList();
+            Intrinsics.checkNotNull(substringIndexList);
+            Integer num = substringIndexList.get(0);
+            Integer num2 = substringIndexList.get(1);
+            Intrinsics.checkNotNull(num);
+            if (num.intValue() >= 0) {
+                int intValue = num.intValue();
+                Intrinsics.checkNotNull(num2);
+                if (intValue <= num2.intValue() && num2.intValue() <= str.length()) {
+                    Intrinsics.checkNotNull(str);
+                    str = str.substring(num.intValue(), num2.intValue());
+                    Intrinsics.checkNotNullExpressionValue(str, "substring(...)");
+                }
+            }
+        }
+        if (record.getReplaceCharCount() >= 2) {
+            List<Integer> replaceCharList = record.getReplaceCharList();
+            Intrinsics.checkNotNull(replaceCharList);
+            Integer num3 = replaceCharList.get(0);
+            Integer num4 = replaceCharList.get(1);
+            Intrinsics.checkNotNull(str);
+            str = StringsKt__StringsJVMKt.replace$default(str, (char) num3.intValue(), (char) num4.intValue(), false, 4, (Object) null);
+        }
+        JvmProtoBuf.StringTableTypes.Record.Operation operation = record.getOperation();
+        if (operation == null) {
+            operation = JvmProtoBuf.StringTableTypes.Record.Operation.NONE;
+        }
+        int i4 = WhenMappings.$EnumSwitchMapping$0[operation.ordinal()];
+        if (i4 == 2) {
+            Intrinsics.checkNotNull(str);
+            str = StringsKt__StringsJVMKt.replace$default(str, Typography.dollar, '.', false, 4, (Object) null);
+        } else if (i4 == 3) {
+            if (str.length() >= 2) {
+                Intrinsics.checkNotNull(str);
+                str = str.substring(1, str.length() - 1);
+                Intrinsics.checkNotNullExpressionValue(str, "substring(...)");
+            }
+            Intrinsics.checkNotNull(str);
+            str = StringsKt__StringsJVMKt.replace$default(str, Typography.dollar, '.', false, 4, (Object) null);
+        }
+        Intrinsics.checkNotNull(str);
+        return str;
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.metadata.deserialization.NameResolver
+    public boolean isLocalClassName(int i) {
+        return this.localNameIndices.contains(Integer.valueOf(i));
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/jvm/deserialization/JvmNameResolverKt.java

@@ -0,0 +1,23 @@
+package kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization;
+
+import java.util.ArrayList;
+import java.util.List;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.reflect.jvm.internal.impl.metadata.jvm.JvmProtoBuf;
+
+/* loaded from: classes3.dex */
+public final class JvmNameResolverKt {
+    public static final List<JvmProtoBuf.StringTableTypes.Record> toExpandedRecordsList(List<JvmProtoBuf.StringTableTypes.Record> list) {
+        Intrinsics.checkNotNullParameter(list, "<this>");
+        ArrayList arrayList = new ArrayList();
+        arrayList.ensureCapacity(list.size());
+        for (JvmProtoBuf.StringTableTypes.Record record : list) {
+            int range = record.getRange();
+            for (int i = 0; i < range; i++) {
+                arrayList.add(record);
+            }
+        }
+        arrayList.trimToSize();
+        return arrayList;
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/jvm/deserialization/JvmProtoBufUtil.java

@@ -0,0 +1,226 @@
+package kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization;
+
+import C.w;
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import kotlin.Pair;
+import kotlin.collections.CollectionsKt;
+import kotlin.collections.CollectionsKt__IterablesKt;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.jvm.JvmStatic;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.reflect.jvm.internal.impl.metadata.ProtoBuf;
+import kotlin.reflect.jvm.internal.impl.metadata.deserialization.Flags;
+import kotlin.reflect.jvm.internal.impl.metadata.deserialization.NameResolver;
+import kotlin.reflect.jvm.internal.impl.metadata.deserialization.ProtoBufUtilKt;
+import kotlin.reflect.jvm.internal.impl.metadata.deserialization.ProtoTypeTableUtilKt;
+import kotlin.reflect.jvm.internal.impl.metadata.deserialization.TypeTable;
+import kotlin.reflect.jvm.internal.impl.metadata.jvm.JvmProtoBuf;
+import kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization.JvmMemberSignature;
+import kotlin.reflect.jvm.internal.impl.protobuf.ExtensionRegistryLite;
+import kotlin.reflect.jvm.internal.impl.protobuf.GeneratedMessageLite;
+
+@SourceDebugExtension({"SMAP\nJvmProtoBufUtil.kt\nKotlin\n*S Kotlin\n*F\n+ 1 JvmProtoBufUtil.kt\norg/jetbrains/kotlin/metadata/jvm/deserialization/JvmProtoBufUtil\n+ 2 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n+ 3 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,141:1\n1549#2:142\n1620#2,3:143\n1549#2:146\n1620#2,3:147\n1549#2:150\n1620#2,3:151\n1#3:154\n*S KotlinDebug\n*F\n+ 1 JvmProtoBufUtil.kt\norg/jetbrains/kotlin/metadata/jvm/deserialization/JvmProtoBufUtil\n*L\n79#1:142\n79#1:143,3\n81#1:146\n81#1:147,3\n103#1:150\n103#1:151,3\n*E\n"})
+/* loaded from: classes3.dex */
+public final class JvmProtoBufUtil {
+    private static final ExtensionRegistryLite EXTENSION_REGISTRY;
+    public static final JvmProtoBufUtil INSTANCE = new JvmProtoBufUtil();
+
+    static {
+        ExtensionRegistryLite newInstance = ExtensionRegistryLite.newInstance();
+        JvmProtoBuf.registerAllExtensions(newInstance);
+        Intrinsics.checkNotNullExpressionValue(newInstance, "apply(...)");
+        EXTENSION_REGISTRY = newInstance;
+    }
+
+    private JvmProtoBufUtil() {
+    }
+
+    public static /* synthetic */ JvmMemberSignature.Field getJvmFieldSignature$default(JvmProtoBufUtil jvmProtoBufUtil, ProtoBuf.Property property, NameResolver nameResolver, TypeTable typeTable, boolean z3, int i, Object obj) {
+        if ((i & 8) != 0) {
+            z3 = true;
+        }
+        return jvmProtoBufUtil.getJvmFieldSignature(property, nameResolver, typeTable, z3);
+    }
+
+    @JvmStatic
+    public static final boolean isMovedFromInterfaceCompanion(ProtoBuf.Property proto) {
+        Intrinsics.checkNotNullParameter(proto, "proto");
+        Flags.BooleanFlagField is_moved_from_interface_companion = JvmFlags.INSTANCE.getIS_MOVED_FROM_INTERFACE_COMPANION();
+        Object extension = proto.getExtension(JvmProtoBuf.flags);
+        Intrinsics.checkNotNullExpressionValue(extension, "getExtension(...)");
+        Boolean bool = is_moved_from_interface_companion.get(((Number) extension).intValue());
+        Intrinsics.checkNotNullExpressionValue(bool, "get(...)");
+        return bool.booleanValue();
+    }
+
+    private final String mapTypeDefault(ProtoBuf.Type type, NameResolver nameResolver) {
+        if (type.hasClassName()) {
+            return ClassMapperLite.mapClass(nameResolver.getQualifiedClassName(type.getClassName()));
+        }
+        return null;
+    }
+
+    @JvmStatic
+    public static final Pair<JvmNameResolver, ProtoBuf.Class> readClassDataFrom(String[] data, String[] strings) {
+        Intrinsics.checkNotNullParameter(data, "data");
+        Intrinsics.checkNotNullParameter(strings, "strings");
+        byte[] decodeBytes = BitEncoding.decodeBytes(data);
+        Intrinsics.checkNotNullExpressionValue(decodeBytes, "decodeBytes(...)");
+        return readClassDataFrom(decodeBytes, strings);
+    }
+
+    @JvmStatic
+    public static final Pair<JvmNameResolver, ProtoBuf.Function> readFunctionDataFrom(String[] data, String[] strings) {
+        Intrinsics.checkNotNullParameter(data, "data");
+        Intrinsics.checkNotNullParameter(strings, "strings");
+        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(BitEncoding.decodeBytes(data));
+        return new Pair<>(INSTANCE.readNameResolver(byteArrayInputStream, strings), ProtoBuf.Function.parseFrom(byteArrayInputStream, EXTENSION_REGISTRY));
+    }
+
+    private final JvmNameResolver readNameResolver(InputStream inputStream, String[] strArr) {
+        JvmProtoBuf.StringTableTypes parseDelimitedFrom = JvmProtoBuf.StringTableTypes.parseDelimitedFrom(inputStream, EXTENSION_REGISTRY);
+        Intrinsics.checkNotNullExpressionValue(parseDelimitedFrom, "parseDelimitedFrom(...)");
+        return new JvmNameResolver(parseDelimitedFrom, strArr);
+    }
+
+    @JvmStatic
+    public static final Pair<JvmNameResolver, ProtoBuf.Package> readPackageDataFrom(String[] data, String[] strings) {
+        Intrinsics.checkNotNullParameter(data, "data");
+        Intrinsics.checkNotNullParameter(strings, "strings");
+        byte[] decodeBytes = BitEncoding.decodeBytes(data);
+        Intrinsics.checkNotNullExpressionValue(decodeBytes, "decodeBytes(...)");
+        return readPackageDataFrom(decodeBytes, strings);
+    }
+
+    public final ExtensionRegistryLite getEXTENSION_REGISTRY() {
+        return EXTENSION_REGISTRY;
+    }
+
+    public final JvmMemberSignature.Method getJvmConstructorSignature(ProtoBuf.Constructor proto, NameResolver nameResolver, TypeTable typeTable) {
+        int collectionSizeOrDefault;
+        String joinToString$default;
+        Intrinsics.checkNotNullParameter(proto, "proto");
+        Intrinsics.checkNotNullParameter(nameResolver, "nameResolver");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        GeneratedMessageLite.GeneratedExtension<ProtoBuf.Constructor, JvmProtoBuf.JvmMethodSignature> constructorSignature = JvmProtoBuf.constructorSignature;
+        Intrinsics.checkNotNullExpressionValue(constructorSignature, "constructorSignature");
+        JvmProtoBuf.JvmMethodSignature jvmMethodSignature = (JvmProtoBuf.JvmMethodSignature) ProtoBufUtilKt.getExtensionOrNull(proto, constructorSignature);
+        String string = (jvmMethodSignature == null || !jvmMethodSignature.hasName()) ? "<init>" : nameResolver.getString(jvmMethodSignature.getName());
+        if (jvmMethodSignature == null || !jvmMethodSignature.hasDesc()) {
+            List<ProtoBuf.ValueParameter> valueParameterList = proto.getValueParameterList();
+            Intrinsics.checkNotNullExpressionValue(valueParameterList, "getValueParameterList(...)");
+            List<ProtoBuf.ValueParameter> list = valueParameterList;
+            collectionSizeOrDefault = CollectionsKt__IterablesKt.collectionSizeOrDefault(list, 10);
+            ArrayList arrayList = new ArrayList(collectionSizeOrDefault);
+            for (ProtoBuf.ValueParameter valueParameter : list) {
+                JvmProtoBufUtil jvmProtoBufUtil = INSTANCE;
+                Intrinsics.checkNotNull(valueParameter);
+                String mapTypeDefault = jvmProtoBufUtil.mapTypeDefault(ProtoTypeTableUtilKt.type(valueParameter, typeTable), nameResolver);
+                if (mapTypeDefault == null) {
+                    return null;
+                }
+                arrayList.add(mapTypeDefault);
+            }
+            joinToString$default = CollectionsKt___CollectionsKt.joinToString$default(arrayList, "", "(", ")V", 0, null, null, 56, null);
+        } else {
+            joinToString$default = nameResolver.getString(jvmMethodSignature.getDesc());
+        }
+        return new JvmMemberSignature.Method(string, joinToString$default);
+    }
+
+    public final JvmMemberSignature.Field getJvmFieldSignature(ProtoBuf.Property proto, NameResolver nameResolver, TypeTable typeTable, boolean z3) {
+        String mapTypeDefault;
+        Intrinsics.checkNotNullParameter(proto, "proto");
+        Intrinsics.checkNotNullParameter(nameResolver, "nameResolver");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        GeneratedMessageLite.GeneratedExtension<ProtoBuf.Property, JvmProtoBuf.JvmPropertySignature> propertySignature = JvmProtoBuf.propertySignature;
+        Intrinsics.checkNotNullExpressionValue(propertySignature, "propertySignature");
+        JvmProtoBuf.JvmPropertySignature jvmPropertySignature = (JvmProtoBuf.JvmPropertySignature) ProtoBufUtilKt.getExtensionOrNull(proto, propertySignature);
+        if (jvmPropertySignature == null) {
+            return null;
+        }
+        JvmProtoBuf.JvmFieldSignature field = jvmPropertySignature.hasField() ? jvmPropertySignature.getField() : null;
+        if (field == null && z3) {
+            return null;
+        }
+        int name = (field == null || !field.hasName()) ? proto.getName() : field.getName();
+        if (field == null || !field.hasDesc()) {
+            mapTypeDefault = mapTypeDefault(ProtoTypeTableUtilKt.returnType(proto, typeTable), nameResolver);
+            if (mapTypeDefault == null) {
+                return null;
+            }
+        } else {
+            mapTypeDefault = nameResolver.getString(field.getDesc());
+        }
+        return new JvmMemberSignature.Field(nameResolver.getString(name), mapTypeDefault);
+    }
+
+    public final JvmMemberSignature.Method getJvmMethodSignature(ProtoBuf.Function proto, NameResolver nameResolver, TypeTable typeTable) {
+        int collectionSizeOrDefault;
+        int collectionSizeOrDefault2;
+        String joinToString$default;
+        String r4;
+        Intrinsics.checkNotNullParameter(proto, "proto");
+        Intrinsics.checkNotNullParameter(nameResolver, "nameResolver");
+        Intrinsics.checkNotNullParameter(typeTable, "typeTable");
+        GeneratedMessageLite.GeneratedExtension<ProtoBuf.Function, JvmProtoBuf.JvmMethodSignature> methodSignature = JvmProtoBuf.methodSignature;
+        Intrinsics.checkNotNullExpressionValue(methodSignature, "methodSignature");
+        JvmProtoBuf.JvmMethodSignature jvmMethodSignature = (JvmProtoBuf.JvmMethodSignature) ProtoBufUtilKt.getExtensionOrNull(proto, methodSignature);
+        int name = (jvmMethodSignature == null || !jvmMethodSignature.hasName()) ? proto.getName() : jvmMethodSignature.getName();
+        if (jvmMethodSignature == null || !jvmMethodSignature.hasDesc()) {
+            List listOfNotNull = CollectionsKt.listOfNotNull(ProtoTypeTableUtilKt.receiverType(proto, typeTable));
+            List<ProtoBuf.ValueParameter> valueParameterList = proto.getValueParameterList();
+            Intrinsics.checkNotNullExpressionValue(valueParameterList, "getValueParameterList(...)");
+            List<ProtoBuf.ValueParameter> list = valueParameterList;
+            collectionSizeOrDefault = CollectionsKt__IterablesKt.collectionSizeOrDefault(list, 10);
+            ArrayList arrayList = new ArrayList(collectionSizeOrDefault);
+            for (ProtoBuf.ValueParameter valueParameter : list) {
+                Intrinsics.checkNotNull(valueParameter);
+                arrayList.add(ProtoTypeTableUtilKt.type(valueParameter, typeTable));
+            }
+            List plus = CollectionsKt.plus((Collection) listOfNotNull, (Iterable) arrayList);
+            collectionSizeOrDefault2 = CollectionsKt__IterablesKt.collectionSizeOrDefault(plus, 10);
+            ArrayList arrayList2 = new ArrayList(collectionSizeOrDefault2);
+            Iterator it = plus.iterator();
+            while (it.hasNext()) {
+                String mapTypeDefault = INSTANCE.mapTypeDefault((ProtoBuf.Type) it.next(), nameResolver);
+                if (mapTypeDefault == null) {
+                    return null;
+                }
+                arrayList2.add(mapTypeDefault);
+            }
+            String mapTypeDefault2 = mapTypeDefault(ProtoTypeTableUtilKt.returnType(proto, typeTable), nameResolver);
+            if (mapTypeDefault2 == null) {
+                return null;
+            }
+            StringBuilder sb = new StringBuilder();
+            joinToString$default = CollectionsKt___CollectionsKt.joinToString$default(arrayList2, "", "(", ")", 0, null, null, 56, null);
+            r4 = w.r(sb, joinToString$default, mapTypeDefault2);
+        } else {
+            r4 = nameResolver.getString(jvmMethodSignature.getDesc());
+        }
+        return new JvmMemberSignature.Method(nameResolver.getString(name), r4);
+    }
+
+    @JvmStatic
+    public static final Pair<JvmNameResolver, ProtoBuf.Class> readClassDataFrom(byte[] bytes, String[] strings) {
+        Intrinsics.checkNotNullParameter(bytes, "bytes");
+        Intrinsics.checkNotNullParameter(strings, "strings");
+        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
+        return new Pair<>(INSTANCE.readNameResolver(byteArrayInputStream, strings), ProtoBuf.Class.parseFrom(byteArrayInputStream, EXTENSION_REGISTRY));
+    }
+
+    @JvmStatic
+    public static final Pair<JvmNameResolver, ProtoBuf.Package> readPackageDataFrom(byte[] bytes, String[] strings) {
+        Intrinsics.checkNotNullParameter(bytes, "bytes");
+        Intrinsics.checkNotNullParameter(strings, "strings");
+        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
+        return new Pair<>(INSTANCE.readNameResolver(byteArrayInputStream, strings), ProtoBuf.Package.parseFrom(byteArrayInputStream, EXTENSION_REGISTRY));
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/metadata/jvm/deserialization/UtfEncodingKt.java

@@ -0,0 +1,28 @@
+package kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization;
+
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nutfEncoding.kt\nKotlin\n*S Kotlin\n*F\n+ 1 utfEncoding.kt\norg/jetbrains/kotlin/metadata/jvm/deserialization/UtfEncodingKt\n+ 2 ArraysJVM.kt\nkotlin/collections/ArraysKt__ArraysJVMKt\n+ 3 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,73:1\n37#2,2:74\n1#3:76\n*S KotlinDebug\n*F\n+ 1 utfEncoding.kt\norg/jetbrains/kotlin/metadata/jvm/deserialization/UtfEncodingKt\n*L\n55#1:74,2\n*E\n"})
+/* loaded from: classes3.dex */
+public final class UtfEncodingKt {
+    public static final byte[] stringsToBytes(String[] strings) {
+        Intrinsics.checkNotNullParameter(strings, "strings");
+        int i = 0;
+        for (String str : strings) {
+            i += str.length();
+        }
+        byte[] bArr = new byte[i];
+        int i4 = 0;
+        for (String str2 : strings) {
+            int length = str2.length();
+            int i5 = 0;
+            while (i5 < length) {
+                bArr[i4] = (byte) str2.charAt(i5);
+                i5++;
+                i4++;
+            }
+        }
+        return bArr;
+    }
+}