Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/AbstractArrayMapOwner.java

@@ -0,0 +1,47 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import java.util.Iterator;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.markers.KMappedMarker;
+import kotlin.reflect.KClass;
+
+/* loaded from: classes3.dex */
+public abstract class AbstractArrayMapOwner<K, V> implements Iterable<V>, KMappedMarker {
+
+    /* loaded from: classes3.dex */
+    public static abstract class AbstractArrayMapAccessor<K, V, T extends V> {
+        private final int id;
+
+        public AbstractArrayMapAccessor(int i) {
+            this.id = i;
+        }
+
+        public final T extractValue(AbstractArrayMapOwner<K, V> thisRef) {
+            Intrinsics.checkNotNullParameter(thisRef, "thisRef");
+            return thisRef.getArrayMap().get(this.id);
+        }
+    }
+
+    public abstract ArrayMap<V> getArrayMap();
+
+    public abstract TypeRegistry<K, V> getTypeRegistry();
+
+    public final boolean isEmpty() {
+        return getArrayMap().getSize() == 0;
+    }
+
+    @Override // java.lang.Iterable
+    public final Iterator<V> iterator() {
+        return getArrayMap().iterator();
+    }
+
+    public abstract void registerComponent(String str, V v3);
+
+    public final void registerComponent(KClass<? extends K> tClass, V value) {
+        Intrinsics.checkNotNullParameter(tClass, "tClass");
+        Intrinsics.checkNotNullParameter(value, "value");
+        String qualifiedName = tClass.getQualifiedName();
+        Intrinsics.checkNotNull(qualifiedName);
+        registerComponent(qualifiedName, (String) value);
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/AbstractModifierChecks.java

@@ -0,0 +1,21 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import java.util.List;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.reflect.jvm.internal.impl.descriptors.FunctionDescriptor;
+import kotlin.reflect.jvm.internal.impl.util.CheckResult;
+
+/* loaded from: classes3.dex */
+public abstract class AbstractModifierChecks {
+    public final CheckResult check(FunctionDescriptor functionDescriptor) {
+        Intrinsics.checkNotNullParameter(functionDescriptor, "functionDescriptor");
+        for (Checks checks : getChecks$descriptors()) {
+            if (checks.isApplicable(functionDescriptor)) {
+                return checks.checkAll(functionDescriptor);
+            }
+        }
+        return CheckResult.IllegalFunctionName.INSTANCE;
+    }
+
+    public abstract List<Checks> getChecks$descriptors();
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/ArrayMap.java

@@ -0,0 +1,26 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import java.util.Iterator;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes3.dex */
+public abstract class ArrayMap<T> implements Iterable<T>, KMappedMarker {
+    public /* synthetic */ ArrayMap(DefaultConstructorMarker defaultConstructorMarker) {
+        this();
+    }
+
+    public abstract T get(int i);
+
+    public abstract int getSize();
+
+    @Override // java.lang.Iterable
+    public Iterator<T> iterator() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    public abstract void set(int i, T t2);
+
+    private ArrayMap() {
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/ArrayMapImpl.java

@@ -0,0 +1,112 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import java.util.Arrays;
+import java.util.Iterator;
+import kotlin.collections.AbstractIterator;
+import kotlin.collections.ArraysKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nArrayMap.kt\nKotlin\n*S Kotlin\n*F\n+ 1 ArrayMap.kt\norg/jetbrains/kotlin/util/ArrayMapImpl\n+ 2 _Arrays.kt\nkotlin/collections/ArraysKt___ArraysKt\n+ 3 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,145:1\n11245#2,11:146\n13374#2,2:157\n13376#2:160\n11256#2:161\n1#3:159\n*S KotlinDebug\n*F\n+ 1 ArrayMap.kt\norg/jetbrains/kotlin/util/ArrayMapImpl\n*L\n140#1:146,11\n140#1:157,2\n140#1:160\n140#1:161\n140#1:159\n*E\n"})
+/* loaded from: classes3.dex */
+public final class ArrayMapImpl<T> extends ArrayMap<T> {
+    public static final Companion Companion = new Companion(null);
+    private Object[] data;
+    private int size;
+
+    /* loaded from: classes3.dex */
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+
+    private ArrayMapImpl(Object[] objArr, int i) {
+        super(null);
+        this.data = objArr;
+        this.size = i;
+    }
+
+    private final void ensureCapacity(int i) {
+        Object[] objArr = this.data;
+        if (objArr.length > i) {
+            return;
+        }
+        int length = objArr.length;
+        do {
+            length *= 2;
+        } while (length <= i);
+        Object[] copyOf = Arrays.copyOf(this.data, length);
+        Intrinsics.checkNotNullExpressionValue(copyOf, "copyOf(...)");
+        this.data = copyOf;
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.ArrayMap
+    public T get(int i) {
+        return (T) ArraysKt.getOrNull(this.data, i);
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.ArrayMap
+    public int getSize() {
+        return this.size;
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.ArrayMap, java.lang.Iterable
+    public Iterator<T> iterator() {
+        return new AbstractIterator<T>(this) { // from class: kotlin.reflect.jvm.internal.impl.util.ArrayMapImpl$iterator$1
+            private int index = -1;
+            final /* synthetic */ ArrayMapImpl<T> this$0;
+
+            {
+                this.this$0 = this;
+            }
+
+            /* JADX WARN: Multi-variable type inference failed */
+            @Override // kotlin.collections.AbstractIterator
+            public void computeNext() {
+                Object[] objArr;
+                Object[] objArr2;
+                Object[] objArr3;
+                Object[] objArr4;
+                do {
+                    int i = this.index + 1;
+                    this.index = i;
+                    objArr = ((ArrayMapImpl) this.this$0).data;
+                    if (i >= objArr.length) {
+                        break;
+                    } else {
+                        objArr4 = ((ArrayMapImpl) this.this$0).data;
+                    }
+                } while (objArr4[this.index] == null);
+                int i4 = this.index;
+                objArr2 = ((ArrayMapImpl) this.this$0).data;
+                if (i4 >= objArr2.length) {
+                    done();
+                    return;
+                }
+                objArr3 = ((ArrayMapImpl) this.this$0).data;
+                Object obj = objArr3[this.index];
+                Intrinsics.checkNotNull(obj, "null cannot be cast to non-null type T of org.jetbrains.kotlin.util.ArrayMapImpl");
+                setNext(obj);
+            }
+        };
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.ArrayMap
+    public void set(int i, T value) {
+        Intrinsics.checkNotNullParameter(value, "value");
+        ensureCapacity(i);
+        if (this.data[i] == null) {
+            this.size = getSize() + 1;
+        }
+        this.data[i] = value;
+    }
+
+    public ArrayMapImpl() {
+        this(new Object[20], 0);
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/AttributeArrayOwner.java

@@ -0,0 +1,62 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public abstract class AttributeArrayOwner<K, T> extends AbstractArrayMapOwner<K, T> {
+    private ArrayMap<T> arrayMap;
+
+    public AttributeArrayOwner(ArrayMap<T> arrayMap) {
+        Intrinsics.checkNotNullParameter(arrayMap, "arrayMap");
+        this.arrayMap = arrayMap;
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.AbstractArrayMapOwner
+    public final ArrayMap<T> getArrayMap() {
+        return this.arrayMap;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Override // kotlin.reflect.jvm.internal.impl.util.AbstractArrayMapOwner
+    public final void registerComponent(String keyQualifiedName, T value) {
+        Intrinsics.checkNotNullParameter(keyQualifiedName, "keyQualifiedName");
+        Intrinsics.checkNotNullParameter(value, "value");
+        int id = getTypeRegistry().getId(keyQualifiedName);
+        int size = this.arrayMap.getSize();
+        if (size == 0) {
+            this.arrayMap = new OneElementArrayMap(value, id);
+            return;
+        }
+        if (size == 1) {
+            ArrayMap<T> arrayMap = this.arrayMap;
+            Intrinsics.checkNotNull(arrayMap, "null cannot be cast to non-null type org.jetbrains.kotlin.util.OneElementArrayMap<T of org.jetbrains.kotlin.util.AttributeArrayOwner>");
+            OneElementArrayMap oneElementArrayMap = (OneElementArrayMap) arrayMap;
+            if (oneElementArrayMap.getIndex() == id) {
+                this.arrayMap = new OneElementArrayMap(value, id);
+                return;
+            } else {
+                ArrayMapImpl arrayMapImpl = new ArrayMapImpl();
+                this.arrayMap = arrayMapImpl;
+                arrayMapImpl.set(oneElementArrayMap.getIndex(), oneElementArrayMap.getValue());
+            }
+        }
+        this.arrayMap.set(id, value);
+    }
+
+    /* 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 AttributeArrayOwner() {
+        /*
+            r2 = this;
+            kotlin.reflect.jvm.internal.impl.util.EmptyArrayMap r0 = kotlin.reflect.jvm.internal.impl.util.EmptyArrayMap.INSTANCE
+            java.lang.String r1 = "null cannot be cast to non-null type org.jetbrains.kotlin.util.ArrayMap<T of org.jetbrains.kotlin.util.AttributeArrayOwner>"
+            kotlin.jvm.internal.Intrinsics.checkNotNull(r0, r1)
+            r2.<init>(r0)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlin.reflect.jvm.internal.impl.util.AttributeArrayOwner.<init>():void");
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/Check.java

@@ -0,0 +1,25 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.reflect.jvm.internal.impl.descriptors.FunctionDescriptor;
+
+/* loaded from: classes3.dex */
+public interface Check {
+
+    /* loaded from: classes3.dex */
+    public static final class DefaultImpls {
+        public static String invoke(Check check, FunctionDescriptor functionDescriptor) {
+            Intrinsics.checkNotNullParameter(functionDescriptor, "functionDescriptor");
+            if (check.check(functionDescriptor)) {
+                return null;
+            }
+            return check.getDescription();
+        }
+    }
+
+    boolean check(FunctionDescriptor functionDescriptor);
+
+    String getDescription();
+
+    String invoke(FunctionDescriptor functionDescriptor);
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/CheckResult.java

@@ -0,0 +1,51 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public abstract class CheckResult {
+    private final boolean isSuccess;
+
+    /* loaded from: classes3.dex */
+    public static final class IllegalFunctionName extends CheckResult {
+        public static final IllegalFunctionName INSTANCE = new IllegalFunctionName();
+
+        private IllegalFunctionName() {
+            super(false, null);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class IllegalSignature extends CheckResult {
+        private final String error;
+
+        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+        public IllegalSignature(String error) {
+            super(false, null);
+            Intrinsics.checkNotNullParameter(error, "error");
+            this.error = error;
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class SuccessCheck extends CheckResult {
+        public static final SuccessCheck INSTANCE = new SuccessCheck();
+
+        private SuccessCheck() {
+            super(true, null);
+        }
+    }
+
+    public /* synthetic */ CheckResult(boolean z3, DefaultConstructorMarker defaultConstructorMarker) {
+        this(z3);
+    }
+
+    public final boolean isSuccess() {
+        return this.isSuccess;
+    }
+
+    private CheckResult(boolean z3) {
+        this.isSuccess = z3;
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/Checks.java

@@ -0,0 +1,111 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import java.util.Arrays;
+import java.util.Collection;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.reflect.jvm.internal.impl.descriptors.FunctionDescriptor;
+import kotlin.reflect.jvm.internal.impl.name.Name;
+import kotlin.reflect.jvm.internal.impl.util.CheckResult;
+import kotlin.text.Regex;
+
+/* loaded from: classes3.dex */
+public final class Checks {
+    private final Function1<FunctionDescriptor, String> additionalCheck;
+    private final Check[] checks;
+    private final Name name;
+    private final Collection<Name> nameList;
+    private final Regex regex;
+
+    /* JADX WARN: Multi-variable type inference failed */
+    private Checks(Name name, Regex regex, Collection<Name> collection, Function1<? super FunctionDescriptor, String> function1, Check... checkArr) {
+        this.name = name;
+        this.regex = regex;
+        this.nameList = collection;
+        this.additionalCheck = function1;
+        this.checks = checkArr;
+    }
+
+    public final CheckResult checkAll(FunctionDescriptor functionDescriptor) {
+        Intrinsics.checkNotNullParameter(functionDescriptor, "functionDescriptor");
+        for (Check check : this.checks) {
+            String invoke = check.invoke(functionDescriptor);
+            if (invoke != null) {
+                return new CheckResult.IllegalSignature(invoke);
+            }
+        }
+        String invoke2 = this.additionalCheck.invoke(functionDescriptor);
+        return invoke2 != null ? new CheckResult.IllegalSignature(invoke2) : CheckResult.SuccessCheck.INSTANCE;
+    }
+
+    public final boolean isApplicable(FunctionDescriptor functionDescriptor) {
+        Intrinsics.checkNotNullParameter(functionDescriptor, "functionDescriptor");
+        if (this.name != null && !Intrinsics.areEqual(functionDescriptor.getName(), this.name)) {
+            return false;
+        }
+        if (this.regex != null) {
+            String asString = functionDescriptor.getName().asString();
+            Intrinsics.checkNotNullExpressionValue(asString, "asString(...)");
+            if (!this.regex.matches(asString)) {
+                return false;
+            }
+        }
+        Collection<Name> collection = this.nameList;
+        return collection == null || collection.contains(functionDescriptor.getName());
+    }
+
+    public /* synthetic */ Checks(Name name, Check[] checkArr, Function1 function1, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(name, checkArr, (Function1<? super FunctionDescriptor, String>) ((i & 4) != 0 ? new Function1() { // from class: kotlin.reflect.jvm.internal.impl.util.Checks.2
+            @Override // kotlin.jvm.functions.Function1
+            public final Void invoke(FunctionDescriptor functionDescriptor) {
+                Intrinsics.checkNotNullParameter(functionDescriptor, "$this$null");
+                return null;
+            }
+        } : function1));
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public Checks(Name name, Check[] checks, Function1<? super FunctionDescriptor, String> additionalChecks) {
+        this(name, (Regex) null, (Collection<Name>) null, additionalChecks, (Check[]) Arrays.copyOf(checks, checks.length));
+        Intrinsics.checkNotNullParameter(name, "name");
+        Intrinsics.checkNotNullParameter(checks, "checks");
+        Intrinsics.checkNotNullParameter(additionalChecks, "additionalChecks");
+    }
+
+    public /* synthetic */ Checks(Regex regex, Check[] checkArr, Function1 function1, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(regex, checkArr, (Function1<? super FunctionDescriptor, String>) ((i & 4) != 0 ? new Function1() { // from class: kotlin.reflect.jvm.internal.impl.util.Checks.3
+            @Override // kotlin.jvm.functions.Function1
+            public final Void invoke(FunctionDescriptor functionDescriptor) {
+                Intrinsics.checkNotNullParameter(functionDescriptor, "$this$null");
+                return null;
+            }
+        } : function1));
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public Checks(Regex regex, Check[] checks, Function1<? super FunctionDescriptor, String> additionalChecks) {
+        this((Name) null, regex, (Collection<Name>) null, additionalChecks, (Check[]) Arrays.copyOf(checks, checks.length));
+        Intrinsics.checkNotNullParameter(regex, "regex");
+        Intrinsics.checkNotNullParameter(checks, "checks");
+        Intrinsics.checkNotNullParameter(additionalChecks, "additionalChecks");
+    }
+
+    public /* synthetic */ Checks(Collection collection, Check[] checkArr, Function1 function1, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this((Collection<Name>) collection, checkArr, (Function1<? super FunctionDescriptor, String>) ((i & 4) != 0 ? new Function1() { // from class: kotlin.reflect.jvm.internal.impl.util.Checks.4
+            @Override // kotlin.jvm.functions.Function1
+            public final Void invoke(FunctionDescriptor functionDescriptor) {
+                Intrinsics.checkNotNullParameter(functionDescriptor, "$this$null");
+                return null;
+            }
+        } : function1));
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public Checks(Collection<Name> nameList, Check[] checks, Function1<? super FunctionDescriptor, String> additionalChecks) {
+        this((Name) null, (Regex) null, nameList, additionalChecks, (Check[]) Arrays.copyOf(checks, checks.length));
+        Intrinsics.checkNotNullParameter(nameList, "nameList");
+        Intrinsics.checkNotNullParameter(checks, "checks");
+        Intrinsics.checkNotNullParameter(additionalChecks, "additionalChecks");
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/EmptyArrayMap$iterator$1.java

@@ -0,0 +1,23 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes3.dex */
+public final class EmptyArrayMap$iterator$1 implements Iterator, KMappedMarker {
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return false;
+    }
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    @Override // java.util.Iterator
+    public Void next() {
+        throw new NoSuchElementException();
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/EmptyArrayMap.java

@@ -0,0 +1,34 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import java.util.Iterator;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public final class EmptyArrayMap extends ArrayMap {
+    public static final EmptyArrayMap INSTANCE = new EmptyArrayMap();
+
+    private EmptyArrayMap() {
+        super(null);
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.ArrayMap
+    public Void get(int i) {
+        return null;
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.ArrayMap
+    public int getSize() {
+        return 0;
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.ArrayMap, java.lang.Iterable
+    public Iterator iterator() {
+        return new EmptyArrayMap$iterator$1();
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.ArrayMap
+    public void set(int i, Void value) {
+        Intrinsics.checkNotNullParameter(value, "value");
+        throw new IllegalStateException();
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/IsKPropertyCheck.java

@@ -0,0 +1,44 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.reflect.jvm.internal.impl.builtins.ReflectionTypes;
+import kotlin.reflect.jvm.internal.impl.descriptors.FunctionDescriptor;
+import kotlin.reflect.jvm.internal.impl.descriptors.ValueParameterDescriptor;
+import kotlin.reflect.jvm.internal.impl.resolve.descriptorUtil.DescriptorUtilsKt;
+import kotlin.reflect.jvm.internal.impl.types.KotlinType;
+import kotlin.reflect.jvm.internal.impl.types.typeUtil.TypeUtilsKt;
+import kotlin.reflect.jvm.internal.impl.util.Check;
+
+/* loaded from: classes3.dex */
+final class IsKPropertyCheck implements Check {
+    public static final IsKPropertyCheck INSTANCE = new IsKPropertyCheck();
+    private static final String description = "second parameter must be of type KProperty<*> or its supertype";
+
+    private IsKPropertyCheck() {
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.Check
+    public boolean check(FunctionDescriptor functionDescriptor) {
+        Intrinsics.checkNotNullParameter(functionDescriptor, "functionDescriptor");
+        ValueParameterDescriptor valueParameterDescriptor = functionDescriptor.getValueParameters().get(1);
+        ReflectionTypes.Companion companion = ReflectionTypes.Companion;
+        Intrinsics.checkNotNull(valueParameterDescriptor);
+        KotlinType createKPropertyStarType = companion.createKPropertyStarType(DescriptorUtilsKt.getModule(valueParameterDescriptor));
+        if (createKPropertyStarType == null) {
+            return false;
+        }
+        KotlinType type = valueParameterDescriptor.getType();
+        Intrinsics.checkNotNullExpressionValue(type, "getType(...)");
+        return TypeUtilsKt.isSubtypeOf(createKPropertyStarType, TypeUtilsKt.makeNotNullable(type));
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.Check
+    public String getDescription() {
+        return description;
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.Check
+    public String invoke(FunctionDescriptor functionDescriptor) {
+        return Check.DefaultImpls.invoke(this, functionDescriptor);
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/MemberKindCheck.java

@@ -0,0 +1,59 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.reflect.jvm.internal.impl.descriptors.FunctionDescriptor;
+import kotlin.reflect.jvm.internal.impl.util.Check;
+
+/* loaded from: classes3.dex */
+public abstract class MemberKindCheck implements Check {
+    private final String description;
+
+    /* loaded from: classes3.dex */
+    public static final class Member extends MemberKindCheck {
+        public static final Member INSTANCE = new Member();
+
+        private Member() {
+            super("must be a member function", null);
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.util.Check
+        public boolean check(FunctionDescriptor functionDescriptor) {
+            Intrinsics.checkNotNullParameter(functionDescriptor, "functionDescriptor");
+            return functionDescriptor.getDispatchReceiverParameter() != null;
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class MemberOrExtension extends MemberKindCheck {
+        public static final MemberOrExtension INSTANCE = new MemberOrExtension();
+
+        private MemberOrExtension() {
+            super("must be a member or an extension function", null);
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.util.Check
+        public boolean check(FunctionDescriptor functionDescriptor) {
+            Intrinsics.checkNotNullParameter(functionDescriptor, "functionDescriptor");
+            return (functionDescriptor.getDispatchReceiverParameter() == null && functionDescriptor.getExtensionReceiverParameter() == null) ? false : true;
+        }
+    }
+
+    public /* synthetic */ MemberKindCheck(String str, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str);
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.Check
+    public String getDescription() {
+        return this.description;
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.Check
+    public String invoke(FunctionDescriptor functionDescriptor) {
+        return Check.DefaultImpls.invoke(this, functionDescriptor);
+    }
+
+    private MemberKindCheck(String str) {
+        this.description = str;
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/ModuleVisibilityHelper.java

@@ -0,0 +1,25 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptor;
+
+/* loaded from: classes3.dex */
+public interface ModuleVisibilityHelper {
+
+    /* loaded from: classes3.dex */
+    public static final class EMPTY implements ModuleVisibilityHelper {
+        public static final EMPTY INSTANCE = new EMPTY();
+
+        private EMPTY() {
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.util.ModuleVisibilityHelper
+        public boolean isInFriendModule(DeclarationDescriptor what, DeclarationDescriptor from) {
+            Intrinsics.checkNotNullParameter(what, "what");
+            Intrinsics.checkNotNullParameter(from, "from");
+            return true;
+        }
+    }
+
+    boolean isInFriendModule(DeclarationDescriptor declarationDescriptor, DeclarationDescriptor declarationDescriptor2);
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/NoDefaultAndVarargsCheck.java

@@ -0,0 +1,48 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import java.util.Collection;
+import java.util.List;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.reflect.jvm.internal.impl.descriptors.FunctionDescriptor;
+import kotlin.reflect.jvm.internal.impl.descriptors.ValueParameterDescriptor;
+import kotlin.reflect.jvm.internal.impl.resolve.descriptorUtil.DescriptorUtilsKt;
+import kotlin.reflect.jvm.internal.impl.util.Check;
+
+@SourceDebugExtension({"SMAP\nmodifierChecks.kt\nKotlin\n*S Kotlin\n*F\n+ 1 modifierChecks.kt\norg/jetbrains/kotlin/util/NoDefaultAndVarargsCheck\n+ 2 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,264:1\n1726#2,3:265\n*S KotlinDebug\n*F\n+ 1 modifierChecks.kt\norg/jetbrains/kotlin/util/NoDefaultAndVarargsCheck\n*L\n105#1:265,3\n*E\n"})
+/* loaded from: classes3.dex */
+final class NoDefaultAndVarargsCheck implements Check {
+    public static final NoDefaultAndVarargsCheck INSTANCE = new NoDefaultAndVarargsCheck();
+    private static final String description = "should not have varargs or parameters with default values";
+
+    private NoDefaultAndVarargsCheck() {
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.Check
+    public boolean check(FunctionDescriptor functionDescriptor) {
+        Intrinsics.checkNotNullParameter(functionDescriptor, "functionDescriptor");
+        List<ValueParameterDescriptor> valueParameters = functionDescriptor.getValueParameters();
+        Intrinsics.checkNotNullExpressionValue(valueParameters, "getValueParameters(...)");
+        List<ValueParameterDescriptor> list = valueParameters;
+        if ((list instanceof Collection) && list.isEmpty()) {
+            return true;
+        }
+        for (ValueParameterDescriptor valueParameterDescriptor : list) {
+            Intrinsics.checkNotNull(valueParameterDescriptor);
+            if (DescriptorUtilsKt.declaresOrInheritsDefaultValue(valueParameterDescriptor) || valueParameterDescriptor.getVarargElementType() != null) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.Check
+    public String getDescription() {
+        return description;
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.Check
+    public String invoke(FunctionDescriptor functionDescriptor) {
+        return Check.DefaultImpls.invoke(this, functionDescriptor);
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/NullableArrayMapAccessor.java

@@ -0,0 +1,24 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.properties.ReadOnlyProperty;
+import kotlin.reflect.KProperty;
+import kotlin.reflect.jvm.internal.impl.util.AbstractArrayMapOwner;
+
+/* loaded from: classes3.dex */
+public final class NullableArrayMapAccessor<K, V, T extends V> extends AbstractArrayMapOwner.AbstractArrayMapAccessor<K, V, T> implements ReadOnlyProperty<AbstractArrayMapOwner<K, V>, V> {
+    public NullableArrayMapAccessor(int i) {
+        super(i);
+    }
+
+    @Override // kotlin.properties.ReadOnlyProperty
+    public /* bridge */ /* synthetic */ Object getValue(Object obj, KProperty kProperty) {
+        return getValue((AbstractArrayMapOwner) obj, (KProperty<?>) kProperty);
+    }
+
+    public T getValue(AbstractArrayMapOwner<K, V> thisRef, KProperty<?> property) {
+        Intrinsics.checkNotNullParameter(thisRef, "thisRef");
+        Intrinsics.checkNotNullParameter(property, "property");
+        return extractValue(thisRef);
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/OneElementArrayMap$iterator$1.java

@@ -0,0 +1,35 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* JADX INFO: Add missing generic type declarations: [T] */
+/* loaded from: classes3.dex */
+public final class OneElementArrayMap$iterator$1<T> implements Iterator<T>, KMappedMarker {
+    private boolean notVisited = true;
+    final /* synthetic */ OneElementArrayMap<T> this$0;
+
+    public OneElementArrayMap$iterator$1(OneElementArrayMap<T> oneElementArrayMap) {
+        this.this$0 = oneElementArrayMap;
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.notVisited;
+    }
+
+    @Override // java.util.Iterator
+    public T next() {
+        if (!this.notVisited) {
+            throw new NoSuchElementException();
+        }
+        this.notVisited = false;
+        return this.this$0.getValue();
+    }
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/OneElementArrayMap.java

@@ -0,0 +1,50 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import java.util.Iterator;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public final class OneElementArrayMap<T> extends ArrayMap<T> {
+    private final int index;
+    private final T value;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public OneElementArrayMap(T value, int i) {
+        super(null);
+        Intrinsics.checkNotNullParameter(value, "value");
+        this.value = value;
+        this.index = i;
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.ArrayMap
+    public T get(int i) {
+        if (i == this.index) {
+            return this.value;
+        }
+        return null;
+    }
+
+    public final int getIndex() {
+        return this.index;
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.ArrayMap
+    public int getSize() {
+        return 1;
+    }
+
+    public final T getValue() {
+        return this.value;
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.ArrayMap, java.lang.Iterable
+    public Iterator<T> iterator() {
+        return new OneElementArrayMap$iterator$1(this);
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.ArrayMap
+    public void set(int i, T value) {
+        Intrinsics.checkNotNullParameter(value, "value");
+        throw new IllegalStateException();
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/OperatorChecks.java

@@ -0,0 +1,238 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import java.util.List;
+import kotlin.collections.CollectionsKt;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.reflect.jvm.internal.impl.builtins.KotlinBuiltIns;
+import kotlin.reflect.jvm.internal.impl.descriptors.ClassDescriptor;
+import kotlin.reflect.jvm.internal.impl.descriptors.ClassifierDescriptor;
+import kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptor;
+import kotlin.reflect.jvm.internal.impl.descriptors.FindClassInModuleKt;
+import kotlin.reflect.jvm.internal.impl.descriptors.FunctionDescriptor;
+import kotlin.reflect.jvm.internal.impl.descriptors.ReceiverParameterDescriptor;
+import kotlin.reflect.jvm.internal.impl.descriptors.TypeAliasDescriptor;
+import kotlin.reflect.jvm.internal.impl.descriptors.ValueParameterDescriptor;
+import kotlin.reflect.jvm.internal.impl.name.ClassId;
+import kotlin.reflect.jvm.internal.impl.name.Name;
+import kotlin.reflect.jvm.internal.impl.resolve.descriptorUtil.DescriptorUtilsKt;
+import kotlin.reflect.jvm.internal.impl.resolve.scopes.receivers.ImplicitClassReceiver;
+import kotlin.reflect.jvm.internal.impl.resolve.scopes.receivers.ReceiverValue;
+import kotlin.reflect.jvm.internal.impl.types.KotlinType;
+import kotlin.reflect.jvm.internal.impl.types.typeUtil.TypeUtilsKt;
+import kotlin.reflect.jvm.internal.impl.util.MemberKindCheck;
+import kotlin.reflect.jvm.internal.impl.util.ReturnsCheck;
+import kotlin.reflect.jvm.internal.impl.util.ValueParameterCountCheck;
+
+/* loaded from: classes3.dex */
+public final class OperatorChecks extends AbstractModifierChecks {
+    public static final OperatorChecks INSTANCE = new OperatorChecks();
+    private static final List<Checks> checks;
+
+    static {
+        Name name = OperatorNameConventions.GET;
+        MemberKindCheck.MemberOrExtension memberOrExtension = MemberKindCheck.MemberOrExtension.INSTANCE;
+        Checks checks2 = new Checks(name, new Check[]{memberOrExtension, new ValueParameterCountCheck.AtLeast(1)}, (Function1) null, 4, (DefaultConstructorMarker) null);
+        Checks checks3 = new Checks(OperatorNameConventions.SET, new Check[]{memberOrExtension, new ValueParameterCountCheck.AtLeast(2)}, new Function1<FunctionDescriptor, String>() { // from class: kotlin.reflect.jvm.internal.impl.util.OperatorChecks$checks$1
+            @Override // kotlin.jvm.functions.Function1
+            public final String invoke(FunctionDescriptor $receiver) {
+                Intrinsics.checkNotNullParameter($receiver, "$this$$receiver");
+                List<ValueParameterDescriptor> valueParameters = $receiver.getValueParameters();
+                Intrinsics.checkNotNullExpressionValue(valueParameters, "getValueParameters(...)");
+                ValueParameterDescriptor valueParameterDescriptor = (ValueParameterDescriptor) CollectionsKt.lastOrNull((List) valueParameters);
+                boolean z3 = false;
+                if (valueParameterDescriptor != null && !DescriptorUtilsKt.declaresOrInheritsDefaultValue(valueParameterDescriptor) && valueParameterDescriptor.getVarargElementType() == null) {
+                    z3 = true;
+                }
+                OperatorChecks operatorChecks = OperatorChecks.INSTANCE;
+                if (z3) {
+                    return null;
+                }
+                return "last parameter should not have a default value or be a vararg";
+            }
+        });
+        Name name2 = OperatorNameConventions.GET_VALUE;
+        NoDefaultAndVarargsCheck noDefaultAndVarargsCheck = NoDefaultAndVarargsCheck.INSTANCE;
+        ValueParameterCountCheck.AtLeast atLeast = new ValueParameterCountCheck.AtLeast(2);
+        IsKPropertyCheck isKPropertyCheck = IsKPropertyCheck.INSTANCE;
+        Checks checks4 = new Checks(name2, new Check[]{memberOrExtension, noDefaultAndVarargsCheck, atLeast, isKPropertyCheck}, (Function1) null, 4, (DefaultConstructorMarker) null);
+        Checks checks5 = new Checks(OperatorNameConventions.SET_VALUE, new Check[]{memberOrExtension, noDefaultAndVarargsCheck, new ValueParameterCountCheck.AtLeast(3), isKPropertyCheck}, (Function1) null, 4, (DefaultConstructorMarker) null);
+        Checks checks6 = new Checks(OperatorNameConventions.PROVIDE_DELEGATE, new Check[]{memberOrExtension, noDefaultAndVarargsCheck, new ValueParameterCountCheck.Equals(2), isKPropertyCheck}, (Function1) null, 4, (DefaultConstructorMarker) null);
+        Checks checks7 = new Checks(OperatorNameConventions.INVOKE, new Check[]{memberOrExtension}, (Function1) null, 4, (DefaultConstructorMarker) null);
+        Name name3 = OperatorNameConventions.CONTAINS;
+        ValueParameterCountCheck.SingleValueParameter singleValueParameter = ValueParameterCountCheck.SingleValueParameter.INSTANCE;
+        ReturnsCheck.ReturnsBoolean returnsBoolean = ReturnsCheck.ReturnsBoolean.INSTANCE;
+        Checks checks8 = new Checks(name3, new Check[]{memberOrExtension, singleValueParameter, noDefaultAndVarargsCheck, returnsBoolean}, (Function1) null, 4, (DefaultConstructorMarker) null);
+        Name name4 = OperatorNameConventions.ITERATOR;
+        ValueParameterCountCheck.NoValueParameters noValueParameters = ValueParameterCountCheck.NoValueParameters.INSTANCE;
+        checks = CollectionsKt.listOf((Object[]) new Checks[]{checks2, checks3, checks4, checks5, checks6, checks7, checks8, new Checks(name4, new Check[]{memberOrExtension, noValueParameters}, (Function1) null, 4, (DefaultConstructorMarker) null), new Checks(OperatorNameConventions.NEXT, new Check[]{memberOrExtension, noValueParameters}, (Function1) null, 4, (DefaultConstructorMarker) null), new Checks(OperatorNameConventions.HAS_NEXT, new Check[]{memberOrExtension, noValueParameters, returnsBoolean}, (Function1) null, 4, (DefaultConstructorMarker) null), new Checks(OperatorNameConventions.RANGE_TO, new Check[]{memberOrExtension, singleValueParameter, noDefaultAndVarargsCheck}, (Function1) null, 4, (DefaultConstructorMarker) null), new Checks(OperatorNameConventions.RANGE_UNTIL, new Check[]{memberOrExtension, singleValueParameter, noDefaultAndVarargsCheck}, (Function1) null, 4, (DefaultConstructorMarker) null), new Checks(OperatorNameConventions.EQUALS, new Check[]{MemberKindCheck.Member.INSTANCE}, new Function1<FunctionDescriptor, String>() { // from class: kotlin.reflect.jvm.internal.impl.util.OperatorChecks$checks$2
+            private static final boolean invoke$isAny(DeclarationDescriptor declarationDescriptor) {
+                return (declarationDescriptor instanceof ClassDescriptor) && KotlinBuiltIns.isAny((ClassDescriptor) declarationDescriptor);
+            }
+
+            /* JADX WARN: Removed duplicated region for block: B:17:0x0055  */
+            /* JADX WARN: Removed duplicated region for block: B:23:0x00a7 A[RETURN] */
+            @Override // kotlin.jvm.functions.Function1
+            /*
+                Code decompiled incorrectly, please refer to instructions dump.
+                To view partially-correct add '--show-bad-code' argument
+            */
+            public final java.lang.String invoke(kotlin.reflect.jvm.internal.impl.descriptors.FunctionDescriptor r3) {
+                /*
+                    r2 = this;
+                    java.lang.String r2 = "$this$$receiver"
+                    kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r3, r2)
+                    kotlin.reflect.jvm.internal.impl.util.OperatorChecks r2 = kotlin.reflect.jvm.internal.impl.util.OperatorChecks.INSTANCE
+                    kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptor r2 = r3.getContainingDeclaration()
+                    java.lang.String r0 = "getContainingDeclaration(...)"
+                    kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r2, r0)
+                    boolean r2 = invoke$isAny(r2)
+                    if (r2 != 0) goto L52
+                    java.util.Collection r2 = r3.getOverriddenDescriptors()
+                    java.lang.String r1 = "getOverriddenDescriptors(...)"
+                    kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r2, r1)
+                    java.lang.Iterable r2 = (java.lang.Iterable) r2
+                    r1 = r2
+                    java.util.Collection r1 = (java.util.Collection) r1
+                    boolean r1 = r1.isEmpty()
+                    if (r1 == 0) goto L2b
+                    goto L49
+                L2b:
+                    java.util.Iterator r2 = r2.iterator()
+                L2f:
+                    boolean r1 = r2.hasNext()
+                    if (r1 == 0) goto L49
+                    java.lang.Object r1 = r2.next()
+                    kotlin.reflect.jvm.internal.impl.descriptors.FunctionDescriptor r1 = (kotlin.reflect.jvm.internal.impl.descriptors.FunctionDescriptor) r1
+                    kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptor r1 = r1.getContainingDeclaration()
+                    kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r1, r0)
+                    boolean r1 = invoke$isAny(r1)
+                    if (r1 == 0) goto L2f
+                    goto L52
+                L49:
+                    boolean r2 = kotlin.reflect.jvm.internal.impl.descriptors.DescriptorUtilKt.isTypedEqualsInValueClass(r3)
+                    if (r2 == 0) goto L50
+                    goto L52
+                L50:
+                    r2 = 0
+                    goto L53
+                L52:
+                    r2 = 1
+                L53:
+                    if (r2 != 0) goto La7
+                    java.lang.StringBuilder r2 = new java.lang.StringBuilder
+                    java.lang.String r1 = "must override ''equals()'' in Any"
+                    r2.<init>(r1)
+                    kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptor r1 = r3.getContainingDeclaration()
+                    kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r1, r0)
+                    boolean r0 = kotlin.reflect.jvm.internal.impl.resolve.InlineClassesUtilsKt.isValueClass(r1)
+                    if (r0 == 0) goto L9d
+                    kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer r0 = kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer.SHORT_NAMES_IN_TYPES
+                    kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptor r3 = r3.getContainingDeclaration()
+                    java.lang.String r1 = "null cannot be cast to non-null type org.jetbrains.kotlin.descriptors.ClassDescriptor"
+                    kotlin.jvm.internal.Intrinsics.checkNotNull(r3, r1)
+                    kotlin.reflect.jvm.internal.impl.descriptors.ClassDescriptor r3 = (kotlin.reflect.jvm.internal.impl.descriptors.ClassDescriptor) r3
+                    kotlin.reflect.jvm.internal.impl.types.SimpleType r3 = r3.getDefaultType()
+                    java.lang.String r1 = "getDefaultType(...)"
+                    kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r3, r1)
+                    kotlin.reflect.jvm.internal.impl.types.KotlinType r3 = kotlin.reflect.jvm.internal.impl.types.typeUtil.TypeUtilsKt.replaceArgumentsWithStarProjections(r3)
+                    java.lang.String r3 = r0.renderType(r3)
+                    java.lang.StringBuilder r0 = new java.lang.StringBuilder
+                    java.lang.String r1 = " or define ''equals(other: "
+                    r0.<init>(r1)
+                    r0.append(r3)
+                    java.lang.String r3 = "): Boolean''"
+                    r0.append(r3)
+                    java.lang.String r3 = r0.toString()
+                    r2.append(r3)
+                L9d:
+                    java.lang.String r2 = r2.toString()
+                    java.lang.String r3 = "toString(...)"
+                    kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r2, r3)
+                    return r2
+                La7:
+                    r2 = 0
+                    return r2
+                */
+                throw new UnsupportedOperationException("Method not decompiled: kotlin.reflect.jvm.internal.impl.util.OperatorChecks$checks$2.invoke(kotlin.reflect.jvm.internal.impl.descriptors.FunctionDescriptor):java.lang.String");
+            }
+        }), new Checks(OperatorNameConventions.COMPARE_TO, new Check[]{memberOrExtension, ReturnsCheck.ReturnsInt.INSTANCE, singleValueParameter, noDefaultAndVarargsCheck}, (Function1) null, 4, (DefaultConstructorMarker) null), new Checks(OperatorNameConventions.BINARY_OPERATION_NAMES, new Check[]{memberOrExtension, singleValueParameter, noDefaultAndVarargsCheck}, (Function1) null, 4, (DefaultConstructorMarker) null), new Checks(OperatorNameConventions.SIMPLE_UNARY_OPERATION_NAMES, new Check[]{memberOrExtension, noValueParameters}, (Function1) null, 4, (DefaultConstructorMarker) null), new Checks(CollectionsKt.listOf((Object[]) new Name[]{OperatorNameConventions.INC, OperatorNameConventions.DEC}), new Check[]{memberOrExtension}, new Function1<FunctionDescriptor, String>() { // from class: kotlin.reflect.jvm.internal.impl.util.OperatorChecks$checks$3
+            /* JADX WARN: Code restructure failed: missing block: B:11:0x002f, code lost:
+            
+                if (r5 != false) goto L14;
+             */
+            @Override // kotlin.jvm.functions.Function1
+            /*
+                Code decompiled incorrectly, please refer to instructions dump.
+                To view partially-correct add '--show-bad-code' argument
+            */
+            public final java.lang.String invoke(kotlin.reflect.jvm.internal.impl.descriptors.FunctionDescriptor r6) {
+                /*
+                    r5 = this;
+                    java.lang.String r5 = "$this$$receiver"
+                    kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r6, r5)
+                    kotlin.reflect.jvm.internal.impl.descriptors.ReceiverParameterDescriptor r5 = r6.getDispatchReceiverParameter()
+                    if (r5 != 0) goto Lf
+                    kotlin.reflect.jvm.internal.impl.descriptors.ReceiverParameterDescriptor r5 = r6.getExtensionReceiverParameter()
+                Lf:
+                    kotlin.reflect.jvm.internal.impl.util.OperatorChecks r0 = kotlin.reflect.jvm.internal.impl.util.OperatorChecks.INSTANCE
+                    r1 = 0
+                    if (r5 == 0) goto L32
+                    kotlin.reflect.jvm.internal.impl.types.KotlinType r2 = r6.getReturnType()
+                    if (r2 == 0) goto L28
+                    kotlin.reflect.jvm.internal.impl.types.KotlinType r3 = r5.getType()
+                    java.lang.String r4 = "getType(...)"
+                    kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r3, r4)
+                    boolean r2 = kotlin.reflect.jvm.internal.impl.types.typeUtil.TypeUtilsKt.isSubtypeOf(r2, r3)
+                    goto L29
+                L28:
+                    r2 = r1
+                L29:
+                    if (r2 != 0) goto L31
+                    boolean r5 = kotlin.reflect.jvm.internal.impl.util.OperatorChecks.access$incDecCheckForExpectClass(r0, r6, r5)
+                    if (r5 == 0) goto L32
+                L31:
+                    r1 = 1
+                L32:
+                    if (r1 != 0) goto L37
+                    java.lang.String r5 = "receiver must be a supertype of the return type"
+                    return r5
+                L37:
+                    r5 = 0
+                    return r5
+                */
+                throw new UnsupportedOperationException("Method not decompiled: kotlin.reflect.jvm.internal.impl.util.OperatorChecks$checks$3.invoke(kotlin.reflect.jvm.internal.impl.descriptors.FunctionDescriptor):java.lang.String");
+            }
+        }), new Checks(OperatorNameConventions.ASSIGNMENT_OPERATIONS, new Check[]{memberOrExtension, ReturnsCheck.ReturnsUnit.INSTANCE, singleValueParameter, noDefaultAndVarargsCheck}, (Function1) null, 4, (DefaultConstructorMarker) null), new Checks(OperatorNameConventions.COMPONENT_REGEX, new Check[]{memberOrExtension, noValueParameters}, (Function1) null, 4, (DefaultConstructorMarker) null)});
+    }
+
+    private OperatorChecks() {
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final boolean incDecCheckForExpectClass(FunctionDescriptor functionDescriptor, ReceiverParameterDescriptor receiverParameterDescriptor) {
+        ClassId classId;
+        KotlinType returnType;
+        ReceiverValue value = receiverParameterDescriptor.getValue();
+        Intrinsics.checkNotNullExpressionValue(value, "getValue(...)");
+        if (!(value instanceof ImplicitClassReceiver)) {
+            return false;
+        }
+        ClassDescriptor classDescriptor = ((ImplicitClassReceiver) value).getClassDescriptor();
+        if (!classDescriptor.isExpect() || (classId = DescriptorUtilsKt.getClassId(classDescriptor)) == null) {
+            return false;
+        }
+        ClassifierDescriptor findClassifierAcrossModuleDependencies = FindClassInModuleKt.findClassifierAcrossModuleDependencies(DescriptorUtilsKt.getModule(classDescriptor), classId);
+        TypeAliasDescriptor typeAliasDescriptor = findClassifierAcrossModuleDependencies instanceof TypeAliasDescriptor ? (TypeAliasDescriptor) findClassifierAcrossModuleDependencies : null;
+        if (typeAliasDescriptor == null || (returnType = functionDescriptor.getReturnType()) == null) {
+            return false;
+        }
+        return TypeUtilsKt.isSubtypeOf(returnType, typeAliasDescriptor.getExpandedType());
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.AbstractModifierChecks
+    public List<Checks> getChecks$descriptors() {
+        return checks;
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/OperatorNameConventions.java

@@ -0,0 +1,305 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import java.util.Map;
+import java.util.Set;
+import kotlin.TuplesKt;
+import kotlin.collections.MapsKt;
+import kotlin.collections.SetsKt;
+import kotlin.jvm.JvmField;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.reflect.jvm.internal.impl.name.Name;
+import kotlin.text.Regex;
+
+/* loaded from: classes3.dex */
+public final class OperatorNameConventions {
+
+    @JvmField
+    public static final Set<Name> ALL_BINARY_OPERATION_NAMES;
+
+    @JvmField
+    public static final Name AND;
+
+    @JvmField
+    public static final Set<Name> ASSIGNMENT_OPERATIONS;
+
+    @JvmField
+    public static final Set<Name> BINARY_OPERATION_NAMES;
+
+    @JvmField
+    public static final Set<Name> BITWISE_OPERATION_NAMES;
+
+    @JvmField
+    public static final Name COMPARE_TO;
+
+    @JvmField
+    public static final Regex COMPONENT_REGEX;
+
+    @JvmField
+    public static final Name CONTAINS;
+
+    @JvmField
+    public static final Name DEC;
+
+    @JvmField
+    public static final Set<Name> DELEGATED_PROPERTY_OPERATORS;
+
+    @JvmField
+    public static final Name DIV;
+
+    @JvmField
+    public static final Name DIV_ASSIGN;
+
+    @JvmField
+    public static final Name EQUALS;
+
+    @JvmField
+    public static final Name GET;
+
+    @JvmField
+    public static final Name GET_VALUE;
+
+    @JvmField
+    public static final Name HASH_CODE;
+
+    @JvmField
+    public static final Name HAS_NEXT;
+
+    @JvmField
+    public static final Name INC;
+    public static final OperatorNameConventions INSTANCE = new OperatorNameConventions();
+
+    @JvmField
+    public static final Name INV;
+
+    @JvmField
+    public static final Name INVOKE;
+
+    @JvmField
+    public static final Name ITERATOR;
+
+    @JvmField
+    public static final Name MINUS;
+
+    @JvmField
+    public static final Name MINUS_ASSIGN;
+
+    @JvmField
+    public static final Name MOD;
+
+    @JvmField
+    public static final Name MOD_ASSIGN;
+
+    @JvmField
+    public static final Map<Name, Name> MOD_OPERATORS_REPLACEMENT;
+
+    @JvmField
+    public static final Name NEXT;
+
+    @JvmField
+    public static final Name NOT;
+
+    @JvmField
+    public static final Name OR;
+
+    @JvmField
+    public static final Name PLUS;
+
+    @JvmField
+    public static final Name PLUS_ASSIGN;
+
+    @JvmField
+    public static final Name PROVIDE_DELEGATE;
+
+    @JvmField
+    public static final Name RANGE_TO;
+
+    @JvmField
+    public static final Name RANGE_UNTIL;
+
+    @JvmField
+    public static final Name REM;
+
+    @JvmField
+    public static final Name REM_ASSIGN;
+
+    @JvmField
+    public static final Name SET;
+
+    @JvmField
+    public static final Name SET_VALUE;
+
+    @JvmField
+    public static final Name SHL;
+
+    @JvmField
+    public static final Name SHR;
+
+    @JvmField
+    public static final Set<Name> SIMPLE_UNARY_OPERATION_NAMES;
+
+    @JvmField
+    public static final Set<Name> STATEMENT_LIKE_OPERATORS;
+
+    @JvmField
+    public static final Name TIMES;
+
+    @JvmField
+    public static final Name TIMES_ASSIGN;
+
+    @JvmField
+    public static final Name TO_STRING;
+
+    @JvmField
+    public static final Name UNARY_MINUS;
+
+    @JvmField
+    public static final Set<Name> UNARY_OPERATION_NAMES;
+
+    @JvmField
+    public static final Name UNARY_PLUS;
+
+    @JvmField
+    public static final Name USHR;
+
+    @JvmField
+    public static final Name XOR;
+
+    static {
+        Name identifier = Name.identifier("getValue");
+        Intrinsics.checkNotNullExpressionValue(identifier, "identifier(...)");
+        GET_VALUE = identifier;
+        Name identifier2 = Name.identifier("setValue");
+        Intrinsics.checkNotNullExpressionValue(identifier2, "identifier(...)");
+        SET_VALUE = identifier2;
+        Name identifier3 = Name.identifier("provideDelegate");
+        Intrinsics.checkNotNullExpressionValue(identifier3, "identifier(...)");
+        PROVIDE_DELEGATE = identifier3;
+        Name identifier4 = Name.identifier("equals");
+        Intrinsics.checkNotNullExpressionValue(identifier4, "identifier(...)");
+        EQUALS = identifier4;
+        Name identifier5 = Name.identifier("hashCode");
+        Intrinsics.checkNotNullExpressionValue(identifier5, "identifier(...)");
+        HASH_CODE = identifier5;
+        Name identifier6 = Name.identifier("compareTo");
+        Intrinsics.checkNotNullExpressionValue(identifier6, "identifier(...)");
+        COMPARE_TO = identifier6;
+        Name identifier7 = Name.identifier("contains");
+        Intrinsics.checkNotNullExpressionValue(identifier7, "identifier(...)");
+        CONTAINS = identifier7;
+        Name identifier8 = Name.identifier("invoke");
+        Intrinsics.checkNotNullExpressionValue(identifier8, "identifier(...)");
+        INVOKE = identifier8;
+        Name identifier9 = Name.identifier("iterator");
+        Intrinsics.checkNotNullExpressionValue(identifier9, "identifier(...)");
+        ITERATOR = identifier9;
+        Name identifier10 = Name.identifier("get");
+        Intrinsics.checkNotNullExpressionValue(identifier10, "identifier(...)");
+        GET = identifier10;
+        Name identifier11 = Name.identifier("set");
+        Intrinsics.checkNotNullExpressionValue(identifier11, "identifier(...)");
+        SET = identifier11;
+        Name identifier12 = Name.identifier("next");
+        Intrinsics.checkNotNullExpressionValue(identifier12, "identifier(...)");
+        NEXT = identifier12;
+        Name identifier13 = Name.identifier("hasNext");
+        Intrinsics.checkNotNullExpressionValue(identifier13, "identifier(...)");
+        HAS_NEXT = identifier13;
+        Name identifier14 = Name.identifier("toString");
+        Intrinsics.checkNotNullExpressionValue(identifier14, "identifier(...)");
+        TO_STRING = identifier14;
+        COMPONENT_REGEX = new Regex("component\\d+");
+        Name identifier15 = Name.identifier("and");
+        Intrinsics.checkNotNullExpressionValue(identifier15, "identifier(...)");
+        AND = identifier15;
+        Name identifier16 = Name.identifier("or");
+        Intrinsics.checkNotNullExpressionValue(identifier16, "identifier(...)");
+        OR = identifier16;
+        Name identifier17 = Name.identifier("xor");
+        Intrinsics.checkNotNullExpressionValue(identifier17, "identifier(...)");
+        XOR = identifier17;
+        Name identifier18 = Name.identifier("inv");
+        Intrinsics.checkNotNullExpressionValue(identifier18, "identifier(...)");
+        INV = identifier18;
+        Name identifier19 = Name.identifier("shl");
+        Intrinsics.checkNotNullExpressionValue(identifier19, "identifier(...)");
+        SHL = identifier19;
+        Name identifier20 = Name.identifier("shr");
+        Intrinsics.checkNotNullExpressionValue(identifier20, "identifier(...)");
+        SHR = identifier20;
+        Name identifier21 = Name.identifier("ushr");
+        Intrinsics.checkNotNullExpressionValue(identifier21, "identifier(...)");
+        USHR = identifier21;
+        Name identifier22 = Name.identifier("inc");
+        Intrinsics.checkNotNullExpressionValue(identifier22, "identifier(...)");
+        INC = identifier22;
+        Name identifier23 = Name.identifier("dec");
+        Intrinsics.checkNotNullExpressionValue(identifier23, "identifier(...)");
+        DEC = identifier23;
+        Name identifier24 = Name.identifier("plus");
+        Intrinsics.checkNotNullExpressionValue(identifier24, "identifier(...)");
+        PLUS = identifier24;
+        Name identifier25 = Name.identifier("minus");
+        Intrinsics.checkNotNullExpressionValue(identifier25, "identifier(...)");
+        MINUS = identifier25;
+        Name identifier26 = Name.identifier("not");
+        Intrinsics.checkNotNullExpressionValue(identifier26, "identifier(...)");
+        NOT = identifier26;
+        Name identifier27 = Name.identifier("unaryMinus");
+        Intrinsics.checkNotNullExpressionValue(identifier27, "identifier(...)");
+        UNARY_MINUS = identifier27;
+        Name identifier28 = Name.identifier("unaryPlus");
+        Intrinsics.checkNotNullExpressionValue(identifier28, "identifier(...)");
+        UNARY_PLUS = identifier28;
+        Name identifier29 = Name.identifier("times");
+        Intrinsics.checkNotNullExpressionValue(identifier29, "identifier(...)");
+        TIMES = identifier29;
+        Name identifier30 = Name.identifier("div");
+        Intrinsics.checkNotNullExpressionValue(identifier30, "identifier(...)");
+        DIV = identifier30;
+        Name identifier31 = Name.identifier("mod");
+        Intrinsics.checkNotNullExpressionValue(identifier31, "identifier(...)");
+        MOD = identifier31;
+        Name identifier32 = Name.identifier("rem");
+        Intrinsics.checkNotNullExpressionValue(identifier32, "identifier(...)");
+        REM = identifier32;
+        Name identifier33 = Name.identifier("rangeTo");
+        Intrinsics.checkNotNullExpressionValue(identifier33, "identifier(...)");
+        RANGE_TO = identifier33;
+        Name identifier34 = Name.identifier("rangeUntil");
+        Intrinsics.checkNotNullExpressionValue(identifier34, "identifier(...)");
+        RANGE_UNTIL = identifier34;
+        Name identifier35 = Name.identifier("timesAssign");
+        Intrinsics.checkNotNullExpressionValue(identifier35, "identifier(...)");
+        TIMES_ASSIGN = identifier35;
+        Name identifier36 = Name.identifier("divAssign");
+        Intrinsics.checkNotNullExpressionValue(identifier36, "identifier(...)");
+        DIV_ASSIGN = identifier36;
+        Name identifier37 = Name.identifier("modAssign");
+        Intrinsics.checkNotNullExpressionValue(identifier37, "identifier(...)");
+        MOD_ASSIGN = identifier37;
+        Name identifier38 = Name.identifier("remAssign");
+        Intrinsics.checkNotNullExpressionValue(identifier38, "identifier(...)");
+        REM_ASSIGN = identifier38;
+        Name identifier39 = Name.identifier("plusAssign");
+        Intrinsics.checkNotNullExpressionValue(identifier39, "identifier(...)");
+        PLUS_ASSIGN = identifier39;
+        Name identifier40 = Name.identifier("minusAssign");
+        Intrinsics.checkNotNullExpressionValue(identifier40, "identifier(...)");
+        MINUS_ASSIGN = identifier40;
+        UNARY_OPERATION_NAMES = SetsKt.setOf((Object[]) new Name[]{identifier22, identifier23, identifier28, identifier27, identifier26, identifier18});
+        SIMPLE_UNARY_OPERATION_NAMES = SetsKt.setOf((Object[]) new Name[]{identifier28, identifier27, identifier26, identifier18});
+        Set<Name> of = SetsKt.setOf((Object[]) new Name[]{identifier29, identifier24, identifier25, identifier30, identifier31, identifier32, identifier33, identifier34});
+        BINARY_OPERATION_NAMES = of;
+        Set<Name> of2 = SetsKt.setOf((Object[]) new Name[]{identifier15, identifier16, identifier17, identifier18, identifier19, identifier20, identifier21});
+        BITWISE_OPERATION_NAMES = of2;
+        ALL_BINARY_OPERATION_NAMES = SetsKt.plus(SetsKt.plus((Set) of, (Iterable) of2), (Iterable) SetsKt.setOf((Object[]) new Name[]{identifier4, identifier7, identifier6}));
+        Set<Name> of3 = SetsKt.setOf((Object[]) new Name[]{identifier35, identifier36, identifier37, identifier38, identifier39, identifier40});
+        ASSIGNMENT_OPERATIONS = of3;
+        DELEGATED_PROPERTY_OPERATORS = SetsKt.setOf((Object[]) new Name[]{identifier, identifier2, identifier3});
+        MOD_OPERATORS_REPLACEMENT = MapsKt.mapOf(TuplesKt.to(identifier31, identifier32), TuplesKt.to(identifier37, identifier38));
+        STATEMENT_LIKE_OPERATORS = SetsKt.plus(SetsKt.setOf(identifier11), (Iterable) of3);
+    }
+
+    private OperatorNameConventions() {
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/ReturnsCheck.java

@@ -0,0 +1,97 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import C.w;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.reflect.jvm.internal.impl.builtins.KotlinBuiltIns;
+import kotlin.reflect.jvm.internal.impl.descriptors.FunctionDescriptor;
+import kotlin.reflect.jvm.internal.impl.resolve.descriptorUtil.DescriptorUtilsKt;
+import kotlin.reflect.jvm.internal.impl.types.KotlinType;
+import kotlin.reflect.jvm.internal.impl.types.SimpleType;
+import kotlin.reflect.jvm.internal.impl.util.Check;
+
+/* loaded from: classes3.dex */
+public abstract class ReturnsCheck implements Check {
+    private final String description;
+    private final String name;
+    private final Function1<KotlinBuiltIns, KotlinType> type;
+
+    /* loaded from: classes3.dex */
+    public static final class ReturnsBoolean extends ReturnsCheck {
+        public static final ReturnsBoolean INSTANCE = new ReturnsBoolean();
+
+        private ReturnsBoolean() {
+            super("Boolean", new Function1<KotlinBuiltIns, KotlinType>() { // from class: kotlin.reflect.jvm.internal.impl.util.ReturnsCheck.ReturnsBoolean.1
+                @Override // kotlin.jvm.functions.Function1
+                public final KotlinType invoke(KotlinBuiltIns kotlinBuiltIns) {
+                    Intrinsics.checkNotNullParameter(kotlinBuiltIns, "$this$null");
+                    SimpleType booleanType = kotlinBuiltIns.getBooleanType();
+                    Intrinsics.checkNotNullExpressionValue(booleanType, "getBooleanType(...)");
+                    return booleanType;
+                }
+            }, null);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class ReturnsInt extends ReturnsCheck {
+        public static final ReturnsInt INSTANCE = new ReturnsInt();
+
+        private ReturnsInt() {
+            super("Int", new Function1<KotlinBuiltIns, KotlinType>() { // from class: kotlin.reflect.jvm.internal.impl.util.ReturnsCheck.ReturnsInt.1
+                @Override // kotlin.jvm.functions.Function1
+                public final KotlinType invoke(KotlinBuiltIns kotlinBuiltIns) {
+                    Intrinsics.checkNotNullParameter(kotlinBuiltIns, "$this$null");
+                    SimpleType intType = kotlinBuiltIns.getIntType();
+                    Intrinsics.checkNotNullExpressionValue(intType, "getIntType(...)");
+                    return intType;
+                }
+            }, null);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class ReturnsUnit extends ReturnsCheck {
+        public static final ReturnsUnit INSTANCE = new ReturnsUnit();
+
+        private ReturnsUnit() {
+            super("Unit", new Function1<KotlinBuiltIns, KotlinType>() { // from class: kotlin.reflect.jvm.internal.impl.util.ReturnsCheck.ReturnsUnit.1
+                @Override // kotlin.jvm.functions.Function1
+                public final KotlinType invoke(KotlinBuiltIns kotlinBuiltIns) {
+                    Intrinsics.checkNotNullParameter(kotlinBuiltIns, "$this$null");
+                    SimpleType unitType = kotlinBuiltIns.getUnitType();
+                    Intrinsics.checkNotNullExpressionValue(unitType, "getUnitType(...)");
+                    return unitType;
+                }
+            }, null);
+        }
+    }
+
+    public /* synthetic */ ReturnsCheck(String str, Function1 function1, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, function1);
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.Check
+    public boolean check(FunctionDescriptor functionDescriptor) {
+        Intrinsics.checkNotNullParameter(functionDescriptor, "functionDescriptor");
+        return Intrinsics.areEqual(functionDescriptor.getReturnType(), this.type.invoke(DescriptorUtilsKt.getBuiltIns(functionDescriptor)));
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.Check
+    public String getDescription() {
+        return this.description;
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.Check
+    public String invoke(FunctionDescriptor functionDescriptor) {
+        return Check.DefaultImpls.invoke(this, functionDescriptor);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    private ReturnsCheck(String str, Function1<? super KotlinBuiltIns, ? extends KotlinType> function1) {
+        this.name = str;
+        this.type = function1;
+        this.description = w.z("must return ", str);
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/TypeRegistry.java

@@ -0,0 +1,56 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import java.util.Collection;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.reflect.KClass;
+
+/* loaded from: classes3.dex */
+public abstract class TypeRegistry<K, V> {
+    private final ConcurrentHashMap<String, Integer> idPerType = new ConcurrentHashMap<>();
+    private final AtomicInteger idCounter = new AtomicInteger(0);
+
+    public abstract int customComputeIfAbsent(ConcurrentHashMap<String, Integer> concurrentHashMap, String str, Function1<? super String, Integer> function1);
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public final <T extends V, KK extends K> NullableArrayMapAccessor<K, V, T> generateNullableAccessor(KClass<KK> kClass) {
+        Intrinsics.checkNotNullParameter(kClass, "kClass");
+        return new NullableArrayMapAccessor<>(getId(kClass));
+    }
+
+    public final <T extends K> int getId(KClass<T> kClass) {
+        Intrinsics.checkNotNullParameter(kClass, "kClass");
+        String qualifiedName = kClass.getQualifiedName();
+        Intrinsics.checkNotNull(qualifiedName);
+        return getId(qualifiedName);
+    }
+
+    public final Collection<Integer> getIndices() {
+        Collection<Integer> values = this.idPerType.values();
+        Intrinsics.checkNotNullExpressionValue(values, "<get-values>(...)");
+        return values;
+    }
+
+    public final int getId(String keyQualifiedName) {
+        Intrinsics.checkNotNullParameter(keyQualifiedName, "keyQualifiedName");
+        return customComputeIfAbsent(this.idPerType, keyQualifiedName, new Function1<String, Integer>(this) { // from class: kotlin.reflect.jvm.internal.impl.util.TypeRegistry$getId$1
+            final /* synthetic */ TypeRegistry<K, V> this$0;
+
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(1);
+                this.this$0 = this;
+            }
+
+            @Override // kotlin.jvm.functions.Function1
+            public final Integer invoke(String it) {
+                AtomicInteger atomicInteger;
+                Intrinsics.checkNotNullParameter(it, "it");
+                atomicInteger = ((TypeRegistry) this.this$0).idCounter;
+                return Integer.valueOf(atomicInteger.getAndIncrement());
+            }
+        });
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/ValueParameterCountCheck.java

@@ -0,0 +1,119 @@
+package kotlin.reflect.jvm.internal.impl.util;
+
+import C.w;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.reflect.jvm.internal.impl.descriptors.FunctionDescriptor;
+import kotlin.reflect.jvm.internal.impl.util.Check;
+
+/* loaded from: classes3.dex */
+public abstract class ValueParameterCountCheck implements Check {
+    private final String description;
+
+    /* loaded from: classes3.dex */
+    public static final class AtLeast extends ValueParameterCountCheck {
+
+        /* renamed from: n, reason: collision with root package name */
+        private final int f7142n;
+
+        /* 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 AtLeast(int r3) {
+            /*
+                r2 = this;
+                java.lang.String r0 = "must have at least "
+                java.lang.String r1 = " value parameter"
+                java.lang.StringBuilder r0 = C.w.t(r3, r0, r1)
+                r1 = 1
+                if (r3 <= r1) goto Le
+                java.lang.String r1 = "s"
+                goto L10
+            Le:
+                java.lang.String r1 = ""
+            L10:
+                r0.append(r1)
+                java.lang.String r0 = r0.toString()
+                r1 = 0
+                r2.<init>(r0, r1)
+                r2.f7142n = r3
+                return
+            */
+            throw new UnsupportedOperationException("Method not decompiled: kotlin.reflect.jvm.internal.impl.util.ValueParameterCountCheck.AtLeast.<init>(int):void");
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.util.Check
+        public boolean check(FunctionDescriptor functionDescriptor) {
+            Intrinsics.checkNotNullParameter(functionDescriptor, "functionDescriptor");
+            return functionDescriptor.getValueParameters().size() >= this.f7142n;
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class Equals extends ValueParameterCountCheck {
+
+        /* renamed from: n, reason: collision with root package name */
+        private final int f7143n;
+
+        public Equals(int i) {
+            super(w.i(i, "must have exactly ", " value parameters"), null);
+            this.f7143n = i;
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.util.Check
+        public boolean check(FunctionDescriptor functionDescriptor) {
+            Intrinsics.checkNotNullParameter(functionDescriptor, "functionDescriptor");
+            return functionDescriptor.getValueParameters().size() == this.f7143n;
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class NoValueParameters extends ValueParameterCountCheck {
+        public static final NoValueParameters INSTANCE = new NoValueParameters();
+
+        private NoValueParameters() {
+            super("must have no value parameters", null);
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.util.Check
+        public boolean check(FunctionDescriptor functionDescriptor) {
+            Intrinsics.checkNotNullParameter(functionDescriptor, "functionDescriptor");
+            return functionDescriptor.getValueParameters().isEmpty();
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class SingleValueParameter extends ValueParameterCountCheck {
+        public static final SingleValueParameter INSTANCE = new SingleValueParameter();
+
+        private SingleValueParameter() {
+            super("must have a single value parameter", null);
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.util.Check
+        public boolean check(FunctionDescriptor functionDescriptor) {
+            Intrinsics.checkNotNullParameter(functionDescriptor, "functionDescriptor");
+            return functionDescriptor.getValueParameters().size() == 1;
+        }
+    }
+
+    public /* synthetic */ ValueParameterCountCheck(String str, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str);
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.Check
+    public String getDescription() {
+        return this.description;
+    }
+
+    @Override // kotlin.reflect.jvm.internal.impl.util.Check
+    public String invoke(FunctionDescriptor functionDescriptor) {
+        return Check.DefaultImpls.invoke(this, functionDescriptor);
+    }
+
+    private ValueParameterCountCheck(String str) {
+        this.description = str;
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/capitalizeDecapitalize/CapitalizeDecapitalizeKt.java

@@ -0,0 +1,112 @@
+package kotlin.reflect.jvm.internal.impl.util.capitalizeDecapitalize;
+
+import java.util.Iterator;
+import java.util.Locale;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.ranges.IntRange;
+import kotlin.text.StringsKt__StringsKt;
+
+@SourceDebugExtension({"SMAP\ncapitalizeDecapitalize.kt\nKotlin\n*S Kotlin\n*F\n+ 1 capitalizeDecapitalize.kt\norg/jetbrains/kotlin/util/capitalizeDecapitalize/CapitalizeDecapitalizeKt\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n+ 3 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,144:1\n1#2:145\n288#3,2:146\n288#3,2:148\n766#3:150\n857#3,2:151\n1864#3,3:153\n*S KotlinDebug\n*F\n+ 1 capitalizeDecapitalize.kt\norg/jetbrains/kotlin/util/capitalizeDecapitalize/CapitalizeDecapitalizeKt\n*L\n34#1:146,2\n57#1:148,2\n72#1:150\n72#1:151,2\n78#1:153,3\n*E\n"})
+/* loaded from: classes3.dex */
+public final class CapitalizeDecapitalizeKt {
+    public static final String capitalizeAsciiOnly(String str) {
+        char charAt;
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        if (str.length() == 0 || 'a' > (charAt = str.charAt(0)) || charAt >= '{') {
+            return str;
+        }
+        char upperCase = Character.toUpperCase(charAt);
+        String substring = str.substring(1);
+        Intrinsics.checkNotNullExpressionValue(substring, "substring(...)");
+        return upperCase + substring;
+    }
+
+    public static final String decapitalizeAsciiOnly(String str) {
+        char charAt;
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        if (str.length() == 0 || 'A' > (charAt = str.charAt(0)) || charAt >= '[') {
+            return str;
+        }
+        char lowerCase = Character.toLowerCase(charAt);
+        String substring = str.substring(1);
+        Intrinsics.checkNotNullExpressionValue(substring, "substring(...)");
+        return lowerCase + substring;
+    }
+
+    public static final String decapitalizeSmartForCompiler(String str, boolean z3) {
+        IntRange indices;
+        Integer num;
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        if (str.length() == 0 || !isUpperCaseCharAt(str, 0, z3)) {
+            return str;
+        }
+        if (str.length() == 1 || !isUpperCaseCharAt(str, 1, z3)) {
+            if (z3) {
+                return decapitalizeAsciiOnly(str);
+            }
+            if (str.length() <= 0) {
+                return str;
+            }
+            char lowerCase = Character.toLowerCase(str.charAt(0));
+            String substring = str.substring(1);
+            Intrinsics.checkNotNullExpressionValue(substring, "substring(...)");
+            return lowerCase + substring;
+        }
+        indices = StringsKt__StringsKt.getIndices(str);
+        Iterator<Integer> it = indices.iterator();
+        while (true) {
+            if (!it.hasNext()) {
+                num = null;
+                break;
+            }
+            num = it.next();
+            if (!isUpperCaseCharAt(str, num.intValue(), z3)) {
+                break;
+            }
+        }
+        Integer num2 = num;
+        if (num2 == null) {
+            return toLowerCase(str, z3);
+        }
+        int intValue = num2.intValue() - 1;
+        StringBuilder sb = new StringBuilder();
+        String substring2 = str.substring(0, intValue);
+        Intrinsics.checkNotNullExpressionValue(substring2, "substring(...)");
+        sb.append(toLowerCase(substring2, z3));
+        String substring3 = str.substring(intValue);
+        Intrinsics.checkNotNullExpressionValue(substring3, "substring(...)");
+        sb.append(substring3);
+        return sb.toString();
+    }
+
+    private static final boolean isUpperCaseCharAt(String str, int i, boolean z3) {
+        char charAt = str.charAt(i);
+        return z3 ? 'A' <= charAt && charAt < '[' : Character.isUpperCase(charAt);
+    }
+
+    private static final String toLowerCase(String str, boolean z3) {
+        if (z3) {
+            return toLowerCaseAsciiOnly(str);
+        }
+        String lowerCase = str.toLowerCase(Locale.ROOT);
+        Intrinsics.checkNotNullExpressionValue(lowerCase, "toLowerCase(...)");
+        return lowerCase;
+    }
+
+    public static final String toLowerCaseAsciiOnly(String str) {
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        StringBuilder sb = new StringBuilder(str.length());
+        int length = str.length();
+        for (int i = 0; i < length; i++) {
+            char charAt = str.charAt(i);
+            if ('A' <= charAt && charAt < '[') {
+                charAt = Character.toLowerCase(charAt);
+            }
+            sb.append(charAt);
+        }
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "toString(...)");
+        return sb2;
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/util/collectionUtils/ScopeUtilsKt.java

@@ -0,0 +1,42 @@
+package kotlin.reflect.jvm.internal.impl.util.collectionUtils;
+
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.reflect.jvm.internal.impl.resolve.scopes.MemberScope;
+import kotlin.reflect.jvm.internal.impl.utils.SmartList;
+
+@SourceDebugExtension({"SMAP\nscopeUtils.kt\nKotlin\n*S Kotlin\n*F\n+ 1 scopeUtils.kt\norg/jetbrains/kotlin/util/collectionUtils/ScopeUtilsKt\n+ 2 _Arrays.kt\nkotlin/collections/ArraysKt___ArraysKt\n+ 3 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n+ 4 CollectionUtil.kt\norg/jetbrains/kotlin/utils/CollectionUtilKt\n*L\n1#1,111:1\n4307#2,2:112\n857#3,2:114\n9#4,6:116\n*S KotlinDebug\n*F\n+ 1 scopeUtils.kt\norg/jetbrains/kotlin/util/collectionUtils/ScopeUtilsKt\n*L\n85#1:112,2\n88#1:114,2\n109#1:116,6\n*E\n"})
+/* loaded from: classes3.dex */
+public final class ScopeUtilsKt {
+    /* JADX WARN: Multi-variable type inference failed */
+    public static final <T> Collection<T> concat(Collection<? extends T> collection, Collection<? extends T> collection2) {
+        Intrinsics.checkNotNullParameter(collection2, "collection");
+        if (collection2.isEmpty()) {
+            return collection;
+        }
+        if (collection == 0) {
+            return collection2;
+        }
+        if (collection instanceof LinkedHashSet) {
+            ((LinkedHashSet) collection).addAll(collection2);
+            return collection;
+        }
+        LinkedHashSet linkedHashSet = new LinkedHashSet(collection);
+        linkedHashSet.addAll(collection2);
+        return linkedHashSet;
+    }
+
+    public static final SmartList<MemberScope> listOfNonEmptyScopes(Iterable<? extends MemberScope> scopes) {
+        Intrinsics.checkNotNullParameter(scopes, "scopes");
+        SmartList<MemberScope> smartList = new SmartList<>();
+        for (MemberScope memberScope : scopes) {
+            MemberScope memberScope2 = memberScope;
+            if (memberScope2 != null && memberScope2 != MemberScope.Empty.INSTANCE) {
+                smartList.add(memberScope);
+            }
+        }
+        return smartList;
+    }
+}