Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/renderer/AnnotationArgumentsRenderingPolicy.java

@@ -0,0 +1,53 @@
+package kotlin.reflect.jvm.internal.impl.renderer;
+
+import kotlin.enums.EnumEntries;
+import kotlin.enums.EnumEntriesKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+
+/* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
+/* JADX WARN: Unknown enum class pattern. Please report as an issue! */
+/* loaded from: classes3.dex */
+public final class AnnotationArgumentsRenderingPolicy {
+    private static final /* synthetic */ EnumEntries $ENTRIES;
+    private static final /* synthetic */ AnnotationArgumentsRenderingPolicy[] $VALUES;
+    private final boolean includeAnnotationArguments;
+    private final boolean includeEmptyAnnotationArguments;
+    public static final AnnotationArgumentsRenderingPolicy NO_ARGUMENTS = new AnnotationArgumentsRenderingPolicy("NO_ARGUMENTS", 0, false, false, 3, null);
+    public static final AnnotationArgumentsRenderingPolicy UNLESS_EMPTY = new AnnotationArgumentsRenderingPolicy("UNLESS_EMPTY", 1, true, false, 2, null);
+    public static final AnnotationArgumentsRenderingPolicy ALWAYS_PARENTHESIZED = new AnnotationArgumentsRenderingPolicy("ALWAYS_PARENTHESIZED", 2, true, true);
+
+    private static final /* synthetic */ AnnotationArgumentsRenderingPolicy[] $values() {
+        return new AnnotationArgumentsRenderingPolicy[]{NO_ARGUMENTS, UNLESS_EMPTY, ALWAYS_PARENTHESIZED};
+    }
+
+    static {
+        AnnotationArgumentsRenderingPolicy[] $values = $values();
+        $VALUES = $values;
+        $ENTRIES = EnumEntriesKt.enumEntries($values);
+    }
+
+    private AnnotationArgumentsRenderingPolicy(String str, int i, boolean z3, boolean z4) {
+        this.includeAnnotationArguments = z3;
+        this.includeEmptyAnnotationArguments = z4;
+    }
+
+    public static AnnotationArgumentsRenderingPolicy valueOf(String str) {
+        return (AnnotationArgumentsRenderingPolicy) Enum.valueOf(AnnotationArgumentsRenderingPolicy.class, str);
+    }
+
+    public static AnnotationArgumentsRenderingPolicy[] values() {
+        return (AnnotationArgumentsRenderingPolicy[]) $VALUES.clone();
+    }
+
+    public final boolean getIncludeAnnotationArguments() {
+        return this.includeAnnotationArguments;
+    }
+
+    public final boolean getIncludeEmptyAnnotationArguments() {
+        return this.includeEmptyAnnotationArguments;
+    }
+
+    public /* synthetic */ AnnotationArgumentsRenderingPolicy(String str, int i, boolean z3, boolean z4, int i4, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, i, (i4 & 1) != 0 ? false : z3, (i4 & 2) != 0 ? false : z4);
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/renderer/ClassifierNamePolicy.java

@@ -0,0 +1,116 @@
+package kotlin.reflect.jvm.internal.impl.renderer;
+
+import java.util.ArrayList;
+import java.util.List;
+import kotlin.collections.CollectionsKt__ReversedViewsKt;
+import kotlin.jvm.internal.Intrinsics;
+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.PackageFragmentDescriptor;
+import kotlin.reflect.jvm.internal.impl.descriptors.TypeParameterDescriptor;
+import kotlin.reflect.jvm.internal.impl.name.FqNameUnsafe;
+import kotlin.reflect.jvm.internal.impl.name.Name;
+import kotlin.reflect.jvm.internal.impl.resolve.DescriptorUtils;
+
+/* loaded from: classes3.dex */
+public interface ClassifierNamePolicy {
+
+    /* loaded from: classes3.dex */
+    public static final class FULLY_QUALIFIED implements ClassifierNamePolicy {
+        public static final FULLY_QUALIFIED INSTANCE = new FULLY_QUALIFIED();
+
+        private FULLY_QUALIFIED() {
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.renderer.ClassifierNamePolicy
+        public String renderClassifier(ClassifierDescriptor classifier, DescriptorRenderer renderer) {
+            Intrinsics.checkNotNullParameter(classifier, "classifier");
+            Intrinsics.checkNotNullParameter(renderer, "renderer");
+            if (classifier instanceof TypeParameterDescriptor) {
+                Name name = ((TypeParameterDescriptor) classifier).getName();
+                Intrinsics.checkNotNullExpressionValue(name, "getName(...)");
+                return renderer.renderName(name, false);
+            }
+            FqNameUnsafe fqName = DescriptorUtils.getFqName(classifier);
+            Intrinsics.checkNotNullExpressionValue(fqName, "getFqName(...)");
+            return renderer.renderFqName(fqName);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class SHORT implements ClassifierNamePolicy {
+        public static final SHORT INSTANCE = new SHORT();
+
+        private SHORT() {
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        /* JADX WARN: Type inference failed for: r1v0, types: [kotlin.reflect.jvm.internal.impl.descriptors.ClassifierDescriptor, java.lang.Object] */
+        /* JADX WARN: Type inference failed for: r1v1, types: [kotlin.reflect.jvm.internal.impl.descriptors.Named, kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptor] */
+        /* JADX WARN: Type inference failed for: r1v2, types: [kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptor] */
+        @Override // kotlin.reflect.jvm.internal.impl.renderer.ClassifierNamePolicy
+        public String renderClassifier(ClassifierDescriptor classifier, DescriptorRenderer renderer) {
+            List asReversedMutable;
+            Intrinsics.checkNotNullParameter(classifier, "classifier");
+            Intrinsics.checkNotNullParameter(renderer, "renderer");
+            if (classifier instanceof TypeParameterDescriptor) {
+                Name name = ((TypeParameterDescriptor) classifier).getName();
+                Intrinsics.checkNotNullExpressionValue(name, "getName(...)");
+                return renderer.renderName(name, false);
+            }
+            ArrayList arrayList = new ArrayList();
+            do {
+                arrayList.add(classifier.getName());
+                classifier = classifier.getContainingDeclaration();
+            } while (classifier instanceof ClassDescriptor);
+            asReversedMutable = CollectionsKt__ReversedViewsKt.asReversedMutable(arrayList);
+            return RenderingUtilsKt.renderFqName(asReversedMutable);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class SOURCE_CODE_QUALIFIED implements ClassifierNamePolicy {
+        public static final SOURCE_CODE_QUALIFIED INSTANCE = new SOURCE_CODE_QUALIFIED();
+
+        private SOURCE_CODE_QUALIFIED() {
+        }
+
+        private final String qualifiedNameForSourceCode(ClassifierDescriptor classifierDescriptor) {
+            Name name = classifierDescriptor.getName();
+            Intrinsics.checkNotNullExpressionValue(name, "getName(...)");
+            String render = RenderingUtilsKt.render(name);
+            if (classifierDescriptor instanceof TypeParameterDescriptor) {
+                return render;
+            }
+            DeclarationDescriptor containingDeclaration = classifierDescriptor.getContainingDeclaration();
+            Intrinsics.checkNotNullExpressionValue(containingDeclaration, "getContainingDeclaration(...)");
+            String qualifierName = qualifierName(containingDeclaration);
+            if (qualifierName == null || Intrinsics.areEqual(qualifierName, "")) {
+                return render;
+            }
+            return qualifierName + '.' + render;
+        }
+
+        private final String qualifierName(DeclarationDescriptor declarationDescriptor) {
+            if (declarationDescriptor instanceof ClassDescriptor) {
+                return qualifiedNameForSourceCode((ClassifierDescriptor) declarationDescriptor);
+            }
+            if (!(declarationDescriptor instanceof PackageFragmentDescriptor)) {
+                return null;
+            }
+            FqNameUnsafe unsafe = ((PackageFragmentDescriptor) declarationDescriptor).getFqName().toUnsafe();
+            Intrinsics.checkNotNullExpressionValue(unsafe, "toUnsafe(...)");
+            return RenderingUtilsKt.render(unsafe);
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.renderer.ClassifierNamePolicy
+        public String renderClassifier(ClassifierDescriptor classifier, DescriptorRenderer renderer) {
+            Intrinsics.checkNotNullParameter(classifier, "classifier");
+            Intrinsics.checkNotNullParameter(renderer, "renderer");
+            return qualifiedNameForSourceCode(classifier);
+        }
+    }
+
+    String renderClassifier(ClassifierDescriptor classifierDescriptor, DescriptorRenderer descriptorRenderer);
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/renderer/DescriptorRenderer.java

@@ -0,0 +1,374 @@
+package kotlin.reflect.jvm.internal.impl.renderer;
+
+import com.adif.elcanomovil.resources.IntentUtilKt;
+import kotlin.NoWhenBranchMatchedException;
+import kotlin.Unit;
+import kotlin.collections.SetsKt;
+import kotlin.jvm.JvmField;
+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.ClassKind;
+import kotlin.reflect.jvm.internal.impl.descriptors.ClassifierDescriptorWithTypeParameters;
+import kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptor;
+import kotlin.reflect.jvm.internal.impl.descriptors.TypeAliasDescriptor;
+import kotlin.reflect.jvm.internal.impl.descriptors.ValueParameterDescriptor;
+import kotlin.reflect.jvm.internal.impl.descriptors.annotations.AnnotationDescriptor;
+import kotlin.reflect.jvm.internal.impl.descriptors.annotations.AnnotationUseSiteTarget;
+import kotlin.reflect.jvm.internal.impl.name.FqNameUnsafe;
+import kotlin.reflect.jvm.internal.impl.name.Name;
+import kotlin.reflect.jvm.internal.impl.renderer.ClassifierNamePolicy;
+import kotlin.reflect.jvm.internal.impl.types.KotlinType;
+import kotlin.reflect.jvm.internal.impl.types.TypeProjection;
+
+/* loaded from: classes3.dex */
+public abstract class DescriptorRenderer {
+
+    @JvmField
+    public static final DescriptorRenderer COMPACT;
+
+    @JvmField
+    public static final DescriptorRenderer COMPACT_WITHOUT_SUPERTYPES;
+
+    @JvmField
+    public static final DescriptorRenderer COMPACT_WITH_MODIFIERS;
+
+    @JvmField
+    public static final DescriptorRenderer COMPACT_WITH_SHORT_TYPES;
+    public static final Companion Companion;
+
+    @JvmField
+    public static final DescriptorRenderer DEBUG_TEXT;
+
+    @JvmField
+    public static final DescriptorRenderer FQ_NAMES_IN_TYPES;
+
+    @JvmField
+    public static final DescriptorRenderer FQ_NAMES_IN_TYPES_WITH_ANNOTATIONS;
+
+    @JvmField
+    public static final DescriptorRenderer HTML;
+
+    @JvmField
+    public static final DescriptorRenderer ONLY_NAMES_WITH_SHORT_TYPES;
+
+    @JvmField
+    public static final DescriptorRenderer SHORT_NAMES_IN_TYPES;
+
+    /* loaded from: classes3.dex */
+    public static final class Companion {
+
+        /* loaded from: classes3.dex */
+        public /* synthetic */ class WhenMappings {
+            public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+            static {
+                int[] iArr = new int[ClassKind.values().length];
+                try {
+                    iArr[ClassKind.CLASS.ordinal()] = 1;
+                } catch (NoSuchFieldError unused) {
+                }
+                try {
+                    iArr[ClassKind.INTERFACE.ordinal()] = 2;
+                } catch (NoSuchFieldError unused2) {
+                }
+                try {
+                    iArr[ClassKind.ENUM_CLASS.ordinal()] = 3;
+                } catch (NoSuchFieldError unused3) {
+                }
+                try {
+                    iArr[ClassKind.OBJECT.ordinal()] = 4;
+                } catch (NoSuchFieldError unused4) {
+                }
+                try {
+                    iArr[ClassKind.ANNOTATION_CLASS.ordinal()] = 5;
+                } catch (NoSuchFieldError unused5) {
+                }
+                try {
+                    iArr[ClassKind.ENUM_ENTRY.ordinal()] = 6;
+                } catch (NoSuchFieldError unused6) {
+                }
+                $EnumSwitchMapping$0 = iArr;
+            }
+        }
+
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public final String getClassifierKindPrefix(ClassifierDescriptorWithTypeParameters classifier) {
+            Intrinsics.checkNotNullParameter(classifier, "classifier");
+            if (classifier instanceof TypeAliasDescriptor) {
+                return "typealias";
+            }
+            if (!(classifier instanceof ClassDescriptor)) {
+                throw new AssertionError("Unexpected classifier: " + classifier);
+            }
+            ClassDescriptor classDescriptor = (ClassDescriptor) classifier;
+            if (classDescriptor.isCompanionObject()) {
+                return "companion object";
+            }
+            switch (WhenMappings.$EnumSwitchMapping$0[classDescriptor.getKind().ordinal()]) {
+                case 1:
+                    return "class";
+                case 2:
+                    return "interface";
+                case 3:
+                    return "enum class";
+                case 4:
+                    return IntentUtilKt.DEFAULT_NAME;
+                case 5:
+                    return "annotation class";
+                case 6:
+                    return "enum entry";
+                default:
+                    throw new NoWhenBranchMatchedException();
+            }
+        }
+
+        public final DescriptorRenderer withOptions(Function1<? super DescriptorRendererOptions, Unit> changeOptions) {
+            Intrinsics.checkNotNullParameter(changeOptions, "changeOptions");
+            DescriptorRendererOptionsImpl descriptorRendererOptionsImpl = new DescriptorRendererOptionsImpl();
+            changeOptions.invoke(descriptorRendererOptionsImpl);
+            descriptorRendererOptionsImpl.lock();
+            return new DescriptorRendererImpl(descriptorRendererOptionsImpl);
+        }
+
+        private Companion() {
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public interface ValueParametersHandler {
+
+        /* loaded from: classes3.dex */
+        public static final class DEFAULT implements ValueParametersHandler {
+            public static final DEFAULT INSTANCE = new DEFAULT();
+
+            private DEFAULT() {
+            }
+
+            @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer.ValueParametersHandler
+            public void appendAfterValueParameter(ValueParameterDescriptor parameter, int i, int i4, StringBuilder builder) {
+                Intrinsics.checkNotNullParameter(parameter, "parameter");
+                Intrinsics.checkNotNullParameter(builder, "builder");
+                if (i != i4 - 1) {
+                    builder.append(", ");
+                }
+            }
+
+            @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer.ValueParametersHandler
+            public void appendAfterValueParameters(int i, StringBuilder builder) {
+                Intrinsics.checkNotNullParameter(builder, "builder");
+                builder.append(")");
+            }
+
+            @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer.ValueParametersHandler
+            public void appendBeforeValueParameter(ValueParameterDescriptor parameter, int i, int i4, StringBuilder builder) {
+                Intrinsics.checkNotNullParameter(parameter, "parameter");
+                Intrinsics.checkNotNullParameter(builder, "builder");
+            }
+
+            @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer.ValueParametersHandler
+            public void appendBeforeValueParameters(int i, StringBuilder builder) {
+                Intrinsics.checkNotNullParameter(builder, "builder");
+                builder.append("(");
+            }
+        }
+
+        void appendAfterValueParameter(ValueParameterDescriptor valueParameterDescriptor, int i, int i4, StringBuilder sb);
+
+        void appendAfterValueParameters(int i, StringBuilder sb);
+
+        void appendBeforeValueParameter(ValueParameterDescriptor valueParameterDescriptor, int i, int i4, StringBuilder sb);
+
+        void appendBeforeValueParameters(int i, StringBuilder sb);
+    }
+
+    static {
+        Companion companion = new Companion(null);
+        Companion = companion;
+        COMPACT_WITH_MODIFIERS = companion.withOptions(new Function1<DescriptorRendererOptions, Unit>() { // from class: kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer$Companion$COMPACT_WITH_MODIFIERS$1
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Unit invoke(DescriptorRendererOptions descriptorRendererOptions) {
+                invoke2(descriptorRendererOptions);
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: avoid collision after fix types in other method */
+            public final void invoke2(DescriptorRendererOptions withOptions) {
+                Intrinsics.checkNotNullParameter(withOptions, "$this$withOptions");
+                withOptions.setWithDefinedIn(false);
+            }
+        });
+        COMPACT = companion.withOptions(new Function1<DescriptorRendererOptions, Unit>() { // from class: kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer$Companion$COMPACT$1
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Unit invoke(DescriptorRendererOptions descriptorRendererOptions) {
+                invoke2(descriptorRendererOptions);
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: avoid collision after fix types in other method */
+            public final void invoke2(DescriptorRendererOptions withOptions) {
+                Intrinsics.checkNotNullParameter(withOptions, "$this$withOptions");
+                withOptions.setWithDefinedIn(false);
+                withOptions.setModifiers(SetsKt.emptySet());
+            }
+        });
+        COMPACT_WITHOUT_SUPERTYPES = companion.withOptions(new Function1<DescriptorRendererOptions, Unit>() { // from class: kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer$Companion$COMPACT_WITHOUT_SUPERTYPES$1
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Unit invoke(DescriptorRendererOptions descriptorRendererOptions) {
+                invoke2(descriptorRendererOptions);
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: avoid collision after fix types in other method */
+            public final void invoke2(DescriptorRendererOptions withOptions) {
+                Intrinsics.checkNotNullParameter(withOptions, "$this$withOptions");
+                withOptions.setWithDefinedIn(false);
+                withOptions.setModifiers(SetsKt.emptySet());
+                withOptions.setWithoutSuperTypes(true);
+            }
+        });
+        COMPACT_WITH_SHORT_TYPES = companion.withOptions(new Function1<DescriptorRendererOptions, Unit>() { // from class: kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer$Companion$COMPACT_WITH_SHORT_TYPES$1
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Unit invoke(DescriptorRendererOptions descriptorRendererOptions) {
+                invoke2(descriptorRendererOptions);
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: avoid collision after fix types in other method */
+            public final void invoke2(DescriptorRendererOptions withOptions) {
+                Intrinsics.checkNotNullParameter(withOptions, "$this$withOptions");
+                withOptions.setModifiers(SetsKt.emptySet());
+                withOptions.setClassifierNamePolicy(ClassifierNamePolicy.SHORT.INSTANCE);
+                withOptions.setParameterNameRenderingPolicy(ParameterNameRenderingPolicy.ONLY_NON_SYNTHESIZED);
+            }
+        });
+        ONLY_NAMES_WITH_SHORT_TYPES = companion.withOptions(new Function1<DescriptorRendererOptions, Unit>() { // from class: kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer$Companion$ONLY_NAMES_WITH_SHORT_TYPES$1
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Unit invoke(DescriptorRendererOptions descriptorRendererOptions) {
+                invoke2(descriptorRendererOptions);
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: avoid collision after fix types in other method */
+            public final void invoke2(DescriptorRendererOptions withOptions) {
+                Intrinsics.checkNotNullParameter(withOptions, "$this$withOptions");
+                withOptions.setWithDefinedIn(false);
+                withOptions.setModifiers(SetsKt.emptySet());
+                withOptions.setClassifierNamePolicy(ClassifierNamePolicy.SHORT.INSTANCE);
+                withOptions.setWithoutTypeParameters(true);
+                withOptions.setParameterNameRenderingPolicy(ParameterNameRenderingPolicy.NONE);
+                withOptions.setReceiverAfterName(true);
+                withOptions.setRenderCompanionObjectName(true);
+                withOptions.setWithoutSuperTypes(true);
+                withOptions.setStartFromName(true);
+            }
+        });
+        FQ_NAMES_IN_TYPES = companion.withOptions(new Function1<DescriptorRendererOptions, Unit>() { // from class: kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer$Companion$FQ_NAMES_IN_TYPES$1
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Unit invoke(DescriptorRendererOptions descriptorRendererOptions) {
+                invoke2(descriptorRendererOptions);
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: avoid collision after fix types in other method */
+            public final void invoke2(DescriptorRendererOptions withOptions) {
+                Intrinsics.checkNotNullParameter(withOptions, "$this$withOptions");
+                withOptions.setModifiers(DescriptorRendererModifier.ALL_EXCEPT_ANNOTATIONS);
+            }
+        });
+        FQ_NAMES_IN_TYPES_WITH_ANNOTATIONS = companion.withOptions(new Function1<DescriptorRendererOptions, Unit>() { // from class: kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer$Companion$FQ_NAMES_IN_TYPES_WITH_ANNOTATIONS$1
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Unit invoke(DescriptorRendererOptions descriptorRendererOptions) {
+                invoke2(descriptorRendererOptions);
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: avoid collision after fix types in other method */
+            public final void invoke2(DescriptorRendererOptions withOptions) {
+                Intrinsics.checkNotNullParameter(withOptions, "$this$withOptions");
+                withOptions.setModifiers(DescriptorRendererModifier.ALL);
+            }
+        });
+        SHORT_NAMES_IN_TYPES = companion.withOptions(new Function1<DescriptorRendererOptions, Unit>() { // from class: kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer$Companion$SHORT_NAMES_IN_TYPES$1
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Unit invoke(DescriptorRendererOptions descriptorRendererOptions) {
+                invoke2(descriptorRendererOptions);
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: avoid collision after fix types in other method */
+            public final void invoke2(DescriptorRendererOptions withOptions) {
+                Intrinsics.checkNotNullParameter(withOptions, "$this$withOptions");
+                withOptions.setClassifierNamePolicy(ClassifierNamePolicy.SHORT.INSTANCE);
+                withOptions.setParameterNameRenderingPolicy(ParameterNameRenderingPolicy.ONLY_NON_SYNTHESIZED);
+            }
+        });
+        DEBUG_TEXT = companion.withOptions(new Function1<DescriptorRendererOptions, Unit>() { // from class: kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer$Companion$DEBUG_TEXT$1
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Unit invoke(DescriptorRendererOptions descriptorRendererOptions) {
+                invoke2(descriptorRendererOptions);
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: avoid collision after fix types in other method */
+            public final void invoke2(DescriptorRendererOptions withOptions) {
+                Intrinsics.checkNotNullParameter(withOptions, "$this$withOptions");
+                withOptions.setDebugMode(true);
+                withOptions.setClassifierNamePolicy(ClassifierNamePolicy.FULLY_QUALIFIED.INSTANCE);
+                withOptions.setModifiers(DescriptorRendererModifier.ALL);
+            }
+        });
+        HTML = companion.withOptions(new Function1<DescriptorRendererOptions, Unit>() { // from class: kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer$Companion$HTML$1
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Unit invoke(DescriptorRendererOptions descriptorRendererOptions) {
+                invoke2(descriptorRendererOptions);
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: avoid collision after fix types in other method */
+            public final void invoke2(DescriptorRendererOptions withOptions) {
+                Intrinsics.checkNotNullParameter(withOptions, "$this$withOptions");
+                withOptions.setTextFormat(RenderingFormat.HTML);
+                withOptions.setModifiers(DescriptorRendererModifier.ALL);
+            }
+        });
+    }
+
+    public static /* synthetic */ String renderAnnotation$default(DescriptorRenderer descriptorRenderer, AnnotationDescriptor annotationDescriptor, AnnotationUseSiteTarget annotationUseSiteTarget, int i, Object obj) {
+        if (obj != null) {
+            throw new UnsupportedOperationException("Super calls with default arguments not supported in this target, function: renderAnnotation");
+        }
+        if ((i & 2) != 0) {
+            annotationUseSiteTarget = null;
+        }
+        return descriptorRenderer.renderAnnotation(annotationDescriptor, annotationUseSiteTarget);
+    }
+
+    public abstract String render(DeclarationDescriptor declarationDescriptor);
+
+    public abstract String renderAnnotation(AnnotationDescriptor annotationDescriptor, AnnotationUseSiteTarget annotationUseSiteTarget);
+
+    public abstract String renderFlexibleType(String str, String str2, KotlinBuiltIns kotlinBuiltIns);
+
+    public abstract String renderFqName(FqNameUnsafe fqNameUnsafe);
+
+    public abstract String renderName(Name name, boolean z3);
+
+    public abstract String renderType(KotlinType kotlinType);
+
+    public abstract String renderTypeProjection(TypeProjection typeProjection);
+
+    public final DescriptorRenderer withOptions(Function1<? super DescriptorRendererOptions, Unit> changeOptions) {
+        Intrinsics.checkNotNullParameter(changeOptions, "changeOptions");
+        Intrinsics.checkNotNull(this, "null cannot be cast to non-null type org.jetbrains.kotlin.renderer.DescriptorRendererImpl");
+        DescriptorRendererOptionsImpl copy = ((DescriptorRendererImpl) this).getOptions().copy();
+        changeOptions.invoke(copy);
+        copy.lock();
+        return new DescriptorRendererImpl(copy);
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/renderer/DescriptorRendererModifier.java

@@ -0,0 +1,84 @@
+package kotlin.reflect.jvm.internal.impl.renderer;
+
+import java.util.ArrayList;
+import java.util.Set;
+import kotlin.collections.ArraysKt;
+import kotlin.collections.CollectionsKt;
+import kotlin.enums.EnumEntries;
+import kotlin.enums.EnumEntriesKt;
+import kotlin.jvm.JvmField;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+/* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
+/* JADX WARN: Unknown enum class pattern. Please report as an issue! */
+@SourceDebugExtension({"SMAP\nDescriptorRenderer.kt\nKotlin\n*S Kotlin\n*F\n+ 1 DescriptorRenderer.kt\norg/jetbrains/kotlin/renderer/DescriptorRendererModifier\n+ 2 _Arrays.kt\nkotlin/collections/ArraysKt___ArraysKt\n*L\n1#1,320:1\n3792#2:321\n4307#2,2:322\n*S KotlinDebug\n*F\n+ 1 DescriptorRenderer.kt\norg/jetbrains/kotlin/renderer/DescriptorRendererModifier\n*L\n314#1:321\n314#1:322,2\n*E\n"})
+/* loaded from: classes3.dex */
+public final class DescriptorRendererModifier {
+    private static final /* synthetic */ EnumEntries $ENTRIES;
+    private static final /* synthetic */ DescriptorRendererModifier[] $VALUES;
+
+    @JvmField
+    public static final Set<DescriptorRendererModifier> ALL;
+
+    @JvmField
+    public static final Set<DescriptorRendererModifier> ALL_EXCEPT_ANNOTATIONS;
+    public static final Companion Companion;
+    private final boolean includeByDefault;
+    public static final DescriptorRendererModifier VISIBILITY = new DescriptorRendererModifier("VISIBILITY", 0, true);
+    public static final DescriptorRendererModifier MODALITY = new DescriptorRendererModifier("MODALITY", 1, true);
+    public static final DescriptorRendererModifier OVERRIDE = new DescriptorRendererModifier("OVERRIDE", 2, true);
+    public static final DescriptorRendererModifier ANNOTATIONS = new DescriptorRendererModifier("ANNOTATIONS", 3, false);
+    public static final DescriptorRendererModifier INNER = new DescriptorRendererModifier("INNER", 4, true);
+    public static final DescriptorRendererModifier MEMBER_KIND = new DescriptorRendererModifier("MEMBER_KIND", 5, true);
+    public static final DescriptorRendererModifier DATA = new DescriptorRendererModifier("DATA", 6, true);
+    public static final DescriptorRendererModifier INLINE = new DescriptorRendererModifier("INLINE", 7, true);
+    public static final DescriptorRendererModifier EXPECT = new DescriptorRendererModifier("EXPECT", 8, true);
+    public static final DescriptorRendererModifier ACTUAL = new DescriptorRendererModifier("ACTUAL", 9, true);
+    public static final DescriptorRendererModifier CONST = new DescriptorRendererModifier("CONST", 10, true);
+    public static final DescriptorRendererModifier LATEINIT = new DescriptorRendererModifier("LATEINIT", 11, true);
+    public static final DescriptorRendererModifier FUN = new DescriptorRendererModifier("FUN", 12, true);
+    public static final DescriptorRendererModifier VALUE = new DescriptorRendererModifier("VALUE", 13, true);
+
+    /* loaded from: classes3.dex */
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+
+    private static final /* synthetic */ DescriptorRendererModifier[] $values() {
+        return new DescriptorRendererModifier[]{VISIBILITY, MODALITY, OVERRIDE, ANNOTATIONS, INNER, MEMBER_KIND, DATA, INLINE, EXPECT, ACTUAL, CONST, LATEINIT, FUN, VALUE};
+    }
+
+    static {
+        DescriptorRendererModifier[] $values = $values();
+        $VALUES = $values;
+        $ENTRIES = EnumEntriesKt.enumEntries($values);
+        Companion = new Companion(null);
+        DescriptorRendererModifier[] values = values();
+        ArrayList arrayList = new ArrayList();
+        for (DescriptorRendererModifier descriptorRendererModifier : values) {
+            if (descriptorRendererModifier.includeByDefault) {
+                arrayList.add(descriptorRendererModifier);
+            }
+        }
+        ALL_EXCEPT_ANNOTATIONS = CollectionsKt.toSet(arrayList);
+        ALL = ArraysKt.toSet(values());
+    }
+
+    private DescriptorRendererModifier(String str, int i, boolean z3) {
+        this.includeByDefault = z3;
+    }
+
+    public static DescriptorRendererModifier valueOf(String str) {
+        return (DescriptorRendererModifier) Enum.valueOf(DescriptorRendererModifier.class, str);
+    }
+
+    public static DescriptorRendererModifier[] values() {
+        return (DescriptorRendererModifier[]) $VALUES.clone();
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/renderer/DescriptorRendererOptions.java

@@ -0,0 +1,55 @@
+package kotlin.reflect.jvm.internal.impl.renderer;
+
+import java.util.Set;
+import kotlin.reflect.jvm.internal.impl.name.FqName;
+
+/* loaded from: classes3.dex */
+public interface DescriptorRendererOptions {
+
+    /* loaded from: classes3.dex */
+    public static final class DefaultImpls {
+        public static boolean getIncludeAnnotationArguments(DescriptorRendererOptions descriptorRendererOptions) {
+            return descriptorRendererOptions.getAnnotationArgumentsRenderingPolicy().getIncludeAnnotationArguments();
+        }
+
+        public static boolean getIncludeEmptyAnnotationArguments(DescriptorRendererOptions descriptorRendererOptions) {
+            return descriptorRendererOptions.getAnnotationArgumentsRenderingPolicy().getIncludeEmptyAnnotationArguments();
+        }
+    }
+
+    AnnotationArgumentsRenderingPolicy getAnnotationArgumentsRenderingPolicy();
+
+    boolean getDebugMode();
+
+    boolean getEnhancedTypes();
+
+    Set<FqName> getExcludedTypeAnnotationClasses();
+
+    void setAnnotationArgumentsRenderingPolicy(AnnotationArgumentsRenderingPolicy annotationArgumentsRenderingPolicy);
+
+    void setClassifierNamePolicy(ClassifierNamePolicy classifierNamePolicy);
+
+    void setDebugMode(boolean z3);
+
+    void setExcludedTypeAnnotationClasses(Set<FqName> set);
+
+    void setModifiers(Set<? extends DescriptorRendererModifier> set);
+
+    void setParameterNameRenderingPolicy(ParameterNameRenderingPolicy parameterNameRenderingPolicy);
+
+    void setReceiverAfterName(boolean z3);
+
+    void setRenderCompanionObjectName(boolean z3);
+
+    void setStartFromName(boolean z3);
+
+    void setTextFormat(RenderingFormat renderingFormat);
+
+    void setVerbose(boolean z3);
+
+    void setWithDefinedIn(boolean z3);
+
+    void setWithoutSuperTypes(boolean z3);
+
+    void setWithoutTypeParameters(boolean z3);
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/renderer/ExcludedTypeAnnotations.java

@@ -0,0 +1,18 @@
+package kotlin.reflect.jvm.internal.impl.renderer;
+
+import java.util.Set;
+import kotlin.collections.SetsKt;
+import kotlin.reflect.jvm.internal.impl.name.FqName;
+
+/* loaded from: classes3.dex */
+public final class ExcludedTypeAnnotations {
+    public static final ExcludedTypeAnnotations INSTANCE = new ExcludedTypeAnnotations();
+    private static final Set<FqName> internalAnnotationsForResolve = SetsKt.setOf((Object[]) new FqName[]{new FqName("kotlin.internal.NoInfer"), new FqName("kotlin.internal.Exact")});
+
+    private ExcludedTypeAnnotations() {
+    }
+
+    public final Set<FqName> getInternalAnnotationsForResolve() {
+        return internalAnnotationsForResolve;
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/renderer/KeywordStringsGenerated.java

@@ -0,0 +1,11 @@
+package kotlin.reflect.jvm.internal.impl.renderer;
+
+import com.adif.elcanomovil.resources.IntentUtilKt;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+/* loaded from: classes3.dex */
+public class KeywordStringsGenerated {
+    public static final Set<String> KEYWORDS = new HashSet(Arrays.asList("package", "as", "typealias", "class", "this", "super", "val", "var", "fun", "for", "null", "true", "false", "is", "in", "throw", "return", "break", "continue", IntentUtilKt.DEFAULT_NAME, "if", "try", "else", "while", "do", "when", "interface", "typeof"));
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/renderer/OverrideRenderingPolicy.java

@@ -0,0 +1,36 @@
+package kotlin.reflect.jvm.internal.impl.renderer;
+
+import kotlin.enums.EnumEntries;
+import kotlin.enums.EnumEntriesKt;
+
+/* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
+/* JADX WARN: Unknown enum class pattern. Please report as an issue! */
+/* loaded from: classes3.dex */
+public final class OverrideRenderingPolicy {
+    private static final /* synthetic */ EnumEntries $ENTRIES;
+    private static final /* synthetic */ OverrideRenderingPolicy[] $VALUES;
+    public static final OverrideRenderingPolicy RENDER_OVERRIDE = new OverrideRenderingPolicy("RENDER_OVERRIDE", 0);
+    public static final OverrideRenderingPolicy RENDER_OPEN = new OverrideRenderingPolicy("RENDER_OPEN", 1);
+    public static final OverrideRenderingPolicy RENDER_OPEN_OVERRIDE = new OverrideRenderingPolicy("RENDER_OPEN_OVERRIDE", 2);
+
+    private static final /* synthetic */ OverrideRenderingPolicy[] $values() {
+        return new OverrideRenderingPolicy[]{RENDER_OVERRIDE, RENDER_OPEN, RENDER_OPEN_OVERRIDE};
+    }
+
+    static {
+        OverrideRenderingPolicy[] $values = $values();
+        $VALUES = $values;
+        $ENTRIES = EnumEntriesKt.enumEntries($values);
+    }
+
+    private OverrideRenderingPolicy(String str, int i) {
+    }
+
+    public static OverrideRenderingPolicy valueOf(String str) {
+        return (OverrideRenderingPolicy) Enum.valueOf(OverrideRenderingPolicy.class, str);
+    }
+
+    public static OverrideRenderingPolicy[] values() {
+        return (OverrideRenderingPolicy[]) $VALUES.clone();
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/renderer/ParameterNameRenderingPolicy.java

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

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/renderer/PropertyAccessorRenderingPolicy.java

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

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/renderer/RenderingFormat.java

@@ -0,0 +1,68 @@
+package kotlin.reflect.jvm.internal.impl.renderer;
+
+import kotlin.enums.EnumEntries;
+import kotlin.enums.EnumEntriesKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.StringsKt__StringsJVMKt;
+
+/* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
+/* JADX WARN: Unknown enum class pattern. Please report as an issue! */
+/* loaded from: classes3.dex */
+public abstract class RenderingFormat {
+    private static final /* synthetic */ EnumEntries $ENTRIES;
+    private static final /* synthetic */ RenderingFormat[] $VALUES;
+    public static final RenderingFormat PLAIN = new RenderingFormat("PLAIN", 0) { // from class: kotlin.reflect.jvm.internal.impl.renderer.RenderingFormat.PLAIN
+        {
+            DefaultConstructorMarker defaultConstructorMarker = null;
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.renderer.RenderingFormat
+        public String escape(String string) {
+            Intrinsics.checkNotNullParameter(string, "string");
+            return string;
+        }
+    };
+    public static final RenderingFormat HTML = new RenderingFormat("HTML", 1) { // from class: kotlin.reflect.jvm.internal.impl.renderer.RenderingFormat.HTML
+        {
+            DefaultConstructorMarker defaultConstructorMarker = null;
+        }
+
+        @Override // kotlin.reflect.jvm.internal.impl.renderer.RenderingFormat
+        public String escape(String string) {
+            String replace$default;
+            String replace$default2;
+            Intrinsics.checkNotNullParameter(string, "string");
+            replace$default = StringsKt__StringsJVMKt.replace$default(string, "<", "&lt;", false, 4, (Object) null);
+            replace$default2 = StringsKt__StringsJVMKt.replace$default(replace$default, ">", "&gt;", false, 4, (Object) null);
+            return replace$default2;
+        }
+    };
+
+    private static final /* synthetic */ RenderingFormat[] $values() {
+        return new RenderingFormat[]{PLAIN, HTML};
+    }
+
+    static {
+        RenderingFormat[] $values = $values();
+        $VALUES = $values;
+        $ENTRIES = EnumEntriesKt.enumEntries($values);
+    }
+
+    public /* synthetic */ RenderingFormat(String str, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, i);
+    }
+
+    public static RenderingFormat valueOf(String str) {
+        return (RenderingFormat) Enum.valueOf(RenderingFormat.class, str);
+    }
+
+    public static RenderingFormat[] values() {
+        return (RenderingFormat[]) $VALUES.clone();
+    }
+
+    public abstract String escape(String str);
+
+    private RenderingFormat(String str, int i) {
+    }
+}

apk_decompiled/sources/kotlin/reflect/jvm/internal/impl/renderer/RenderingUtilsKt.java

@@ -0,0 +1,115 @@
+package kotlin.reflect.jvm.internal.impl.renderer;
+
+import C.w;
+import java.util.List;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.reflect.jvm.internal.impl.name.FqNameUnsafe;
+import kotlin.reflect.jvm.internal.impl.name.Name;
+import kotlin.text.StringsKt__StringsJVMKt;
+
+@SourceDebugExtension({"SMAP\nRenderingUtils.kt\nKotlin\n*S Kotlin\n*F\n+ 1 RenderingUtils.kt\norg/jetbrains/kotlin/renderer/RenderingUtilsKt\n+ 2 _Strings.kt\nkotlin/text/StringsKt___StringsKt\n*L\n1#1,78:1\n1083#2,2:79\n*S KotlinDebug\n*F\n+ 1 RenderingUtils.kt\norg/jetbrains/kotlin/renderer/RenderingUtilsKt\n*L\n30#1:79,2\n*E\n"})
+/* loaded from: classes3.dex */
+public final class RenderingUtilsKt {
+    public static final String render(Name name) {
+        Intrinsics.checkNotNullParameter(name, "<this>");
+        if (!shouldBeEscaped(name)) {
+            String asString = name.asString();
+            Intrinsics.checkNotNullExpressionValue(asString, "asString(...)");
+            return asString;
+        }
+        StringBuilder sb = new StringBuilder();
+        String asString2 = name.asString();
+        Intrinsics.checkNotNullExpressionValue(asString2, "asString(...)");
+        sb.append("`" + asString2);
+        sb.append('`');
+        return sb.toString();
+    }
+
+    public static final String renderFqName(List<Name> pathSegments) {
+        Intrinsics.checkNotNullParameter(pathSegments, "pathSegments");
+        StringBuilder sb = new StringBuilder();
+        for (Name name : pathSegments) {
+            if (sb.length() > 0) {
+                sb.append(".");
+            }
+            sb.append(render(name));
+        }
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "toString(...)");
+        return sb2;
+    }
+
+    public static final String replacePrefixesInTypeRepresentations(String lowerRendered, String lowerPrefix, String upperRendered, String upperPrefix, String foldedPrefix) {
+        boolean startsWith$default;
+        boolean startsWith$default2;
+        Intrinsics.checkNotNullParameter(lowerRendered, "lowerRendered");
+        Intrinsics.checkNotNullParameter(lowerPrefix, "lowerPrefix");
+        Intrinsics.checkNotNullParameter(upperRendered, "upperRendered");
+        Intrinsics.checkNotNullParameter(upperPrefix, "upperPrefix");
+        Intrinsics.checkNotNullParameter(foldedPrefix, "foldedPrefix");
+        startsWith$default = StringsKt__StringsJVMKt.startsWith$default(lowerRendered, lowerPrefix, false, 2, null);
+        if (!startsWith$default) {
+            return null;
+        }
+        startsWith$default2 = StringsKt__StringsJVMKt.startsWith$default(upperRendered, upperPrefix, false, 2, null);
+        if (!startsWith$default2) {
+            return null;
+        }
+        String substring = lowerRendered.substring(lowerPrefix.length());
+        Intrinsics.checkNotNullExpressionValue(substring, "substring(...)");
+        String substring2 = upperRendered.substring(upperPrefix.length());
+        Intrinsics.checkNotNullExpressionValue(substring2, "substring(...)");
+        String n4 = w.n(foldedPrefix, substring);
+        if (Intrinsics.areEqual(substring, substring2)) {
+            return n4;
+        }
+        if (!typeStringsDifferOnlyInNullability(substring, substring2)) {
+            return null;
+        }
+        return n4 + '!';
+    }
+
+    private static final boolean shouldBeEscaped(Name name) {
+        String asString = name.asString();
+        Intrinsics.checkNotNullExpressionValue(asString, "asString(...)");
+        if (KeywordStringsGenerated.KEYWORDS.contains(asString)) {
+            return true;
+        }
+        for (int i = 0; i < asString.length(); i++) {
+            char charAt = asString.charAt(i);
+            if (!Character.isLetterOrDigit(charAt) && charAt != '_') {
+                return true;
+            }
+        }
+        return asString.length() == 0 || !Character.isJavaIdentifierStart(asString.codePointAt(0));
+    }
+
+    public static final boolean typeStringsDifferOnlyInNullability(String lower, String upper) {
+        String replace$default;
+        boolean endsWith$default;
+        Intrinsics.checkNotNullParameter(lower, "lower");
+        Intrinsics.checkNotNullParameter(upper, "upper");
+        replace$default = StringsKt__StringsJVMKt.replace$default(upper, "?", "", false, 4, (Object) null);
+        if (Intrinsics.areEqual(lower, replace$default)) {
+            return true;
+        }
+        endsWith$default = StringsKt__StringsJVMKt.endsWith$default(upper, "?", false, 2, null);
+        if (endsWith$default) {
+            if (Intrinsics.areEqual(lower + '?', upper)) {
+                return true;
+            }
+        }
+        StringBuilder sb = new StringBuilder("(");
+        sb.append(lower);
+        sb.append(")?");
+        return Intrinsics.areEqual(sb.toString(), upper);
+    }
+
+    public static final String render(FqNameUnsafe fqNameUnsafe) {
+        Intrinsics.checkNotNullParameter(fqNameUnsafe, "<this>");
+        List<Name> pathSegments = fqNameUnsafe.pathSegments();
+        Intrinsics.checkNotNullExpressionValue(pathSegments, "pathSegments(...)");
+        return renderFqName(pathSegments);
+    }
+}