Initial import of ADIF API reverse-engineering toolkit

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;
+    }
+}