package kotlin.reflect.jvm.internal.impl.types.checker;

import hp.c1;
import hp.d0;
import hp.d1;
import hp.e0;
import hp.f0;
import hp.g0;
import hp.h1;
import hp.j0;
import hp.l0;
import hp.m0;
import hp.m1;
import hp.n1;
import hp.p1;
import hp.s1;
import hp.t1;
import hp.y;
import java.util.Collection;
import java.util.List;
import kotlin.jvm.internal.p0;
import qn.j;
import tn.e1;
import tn.z;

/* loaded from: classes3.dex */
public interface b extends n1, jp.q {

    /* loaded from: classes3.dex */
    public static final class a {

        /* renamed from: kotlin.reflect.jvm.internal.impl.types.checker.b$a$a, reason: collision with other inner class name */
        /* loaded from: classes3.dex */
        public static final class C0571a extends c1.c.a {

            /* renamed from: a, reason: collision with root package name */
            final /* synthetic */ b f26419a;

            /* renamed from: b, reason: collision with root package name */
            final /* synthetic */ m1 f26420b;

            C0571a(b bVar, m1 m1Var) {
                this.f26419a = bVar;
                this.f26420b = m1Var;
            }

            @Override // hp.c1.c
            public jp.j a(c1 state, jp.i type) {
                kotlin.jvm.internal.t.g(state, "state");
                kotlin.jvm.internal.t.g(type, "type");
                b bVar = this.f26419a;
                m1 m1Var = this.f26420b;
                jp.i c02 = bVar.c0(type);
                kotlin.jvm.internal.t.e(c02, "null cannot be cast to non-null type org.jetbrains.kotlin.types.KotlinType");
                e0 n10 = m1Var.n((e0) c02, t1.INVARIANT);
                kotlin.jvm.internal.t.f(n10, "safeSubstitute(...)");
                jp.j c10 = bVar.c(n10);
                kotlin.jvm.internal.t.d(c10);
                return c10;
            }
        }

        public static boolean A(b bVar, jp.i receiver, ro.c fqName) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            kotlin.jvm.internal.t.g(fqName, "fqName");
            if (receiver instanceof e0) {
                return ((e0) receiver).getAnnotations().p0(fqName);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static boolean B(b bVar, jp.n receiver, jp.m mVar) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (!(receiver instanceof e1)) {
                throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
            }
            if (mVar == null ? true : mVar instanceof d1) {
                return kp.a.m((e1) receiver, (d1) mVar, null, 4, null);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static boolean C(b bVar, jp.j a10, jp.j b10) {
            kotlin.jvm.internal.t.g(a10, "a");
            kotlin.jvm.internal.t.g(b10, "b");
            if (!(a10 instanceof m0)) {
                throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + a10 + ", " + p0.b(a10.getClass())).toString());
            }
            if (b10 instanceof m0) {
                return ((m0) a10).I0() == ((m0) b10).I0();
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + b10 + ", " + p0.b(b10.getClass())).toString());
        }

        public static jp.i D(b bVar, List types) {
            kotlin.jvm.internal.t.g(types, "types");
            return d.a(types);
        }

        public static boolean E(b bVar, jp.m receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof d1) {
                return qn.g.w0((d1) receiver, j.a.f33988b);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static boolean F(b bVar, jp.m receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof d1) {
                return ((d1) receiver).p() instanceof tn.e;
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static boolean G(b bVar, jp.m receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof d1) {
                tn.h p10 = ((d1) receiver).p();
                tn.e eVar = p10 instanceof tn.e ? (tn.e) p10 : null;
                return (eVar == null || !tn.e0.a(eVar) || eVar.g() == tn.f.ENUM_ENTRY || eVar.g() == tn.f.ANNOTATION_CLASS) ? false : true;
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static boolean H(b bVar, jp.m receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof d1) {
                return ((d1) receiver).q();
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static boolean I(b bVar, jp.i receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof e0) {
                return g0.a((e0) receiver);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static boolean J(b bVar, jp.m receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof d1) {
                tn.h p10 = ((d1) receiver).p();
                tn.e eVar = p10 instanceof tn.e ? (tn.e) p10 : null;
                return (eVar != null ? eVar.w0() : null) instanceof z;
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static boolean K(b bVar, jp.m receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof d1) {
                return receiver instanceof vo.n;
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static boolean L(b bVar, jp.m receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof d1) {
                return receiver instanceof d0;
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static boolean M(b bVar, jp.j receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof m0) {
                return ((m0) receiver).L0();
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static boolean N(b bVar, jp.i receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            return receiver instanceof j0;
        }

        public static boolean O(b bVar, jp.m receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof d1) {
                return qn.g.w0((d1) receiver, j.a.f33990c);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static boolean P(b bVar, jp.i receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof e0) {
                return p1.l((e0) receiver);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static boolean Q(b bVar, jp.d receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            return receiver instanceof uo.a;
        }

        /* JADX WARN: Multi-variable type inference failed */
        public static boolean R(b bVar, jp.j receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof e0) {
                return qn.g.s0((e0) receiver);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static boolean S(b bVar, jp.d receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof i) {
                return ((i) receiver).W0();
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static boolean T(b bVar, jp.i receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof e0) {
                return receiver instanceof l0;
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        /* JADX WARN: Multi-variable type inference failed */
        public static boolean U(b bVar, jp.j receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (!(receiver instanceof m0)) {
                throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
            }
            if (!g0.a((e0) receiver)) {
                m0 m0Var = (m0) receiver;
                if (!(m0Var.K0().p() instanceof tn.d1) && (m0Var.K0().p() != null || (receiver instanceof uo.a) || (receiver instanceof i) || (receiver instanceof hp.o) || (m0Var.K0() instanceof vo.n) || V(bVar, receiver))) {
                    return true;
                }
            }
            return false;
        }

        private static boolean V(b bVar, jp.j jVar) {
            return (jVar instanceof hp.p0) && bVar.e(((hp.p0) jVar).D0());
        }

        public static boolean W(b bVar, jp.l receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof h1) {
                return ((h1) receiver).b();
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        /* JADX WARN: Multi-variable type inference failed */
        public static boolean X(b bVar, jp.j receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof m0) {
                return kp.a.p((e0) receiver);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        /* JADX WARN: Multi-variable type inference failed */
        public static boolean Y(b bVar, jp.j receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof m0) {
                return kp.a.q((e0) receiver);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static boolean Z(b bVar, jp.i receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (!(receiver instanceof s1)) {
                return false;
            }
            ((s1) receiver).K0();
            return false;
        }

        public static boolean a(b bVar, jp.m c12, jp.m c22) {
            kotlin.jvm.internal.t.g(c12, "c1");
            kotlin.jvm.internal.t.g(c22, "c2");
            if (!(c12 instanceof d1)) {
                throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + c12 + ", " + p0.b(c12.getClass())).toString());
            }
            if (c22 instanceof d1) {
                return kotlin.jvm.internal.t.b(c12, c22);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + c22 + ", " + p0.b(c22.getClass())).toString());
        }

        public static boolean a0(b bVar, jp.m receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof d1) {
                tn.h p10 = ((d1) receiver).p();
                return p10 != null && qn.g.B0(p10);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static int b(b bVar, jp.i receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof e0) {
                return ((e0) receiver).I0().size();
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.j b0(b bVar, jp.g receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof y) {
                return ((y) receiver).S0();
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.k c(b bVar, jp.j receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof m0) {
                return (jp.k) receiver;
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.i c0(b bVar, jp.d receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof i) {
                return ((i) receiver).V0();
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.d d(b bVar, jp.j receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof m0) {
                if (receiver instanceof hp.p0) {
                    return bVar.a(((hp.p0) receiver).D0());
                }
                if (receiver instanceof i) {
                    return (i) receiver;
                }
                return null;
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.i d0(b bVar, jp.i receiver) {
            s1 b10;
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof s1) {
                b10 = c.b((s1) receiver);
                return b10;
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.e e(b bVar, jp.j receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof m0) {
                if (receiver instanceof hp.o) {
                    return (hp.o) receiver;
                }
                return null;
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static c1 e0(b bVar, boolean z10, boolean z11) {
            return kotlin.reflect.jvm.internal.impl.types.checker.a.b(z10, z11, bVar, null, null, 24, null);
        }

        public static jp.f f(b bVar, jp.g receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof y) {
                return null;
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.j f0(b bVar, jp.e receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof hp.o) {
                return ((hp.o) receiver).W0();
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.g g(b bVar, jp.i receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof e0) {
                s1 N0 = ((e0) receiver).N0();
                if (N0 instanceof y) {
                    return (y) N0;
                }
                return null;
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static int g0(b bVar, jp.m receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof d1) {
                return ((d1) receiver).getParameters().size();
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.j h(b bVar, jp.i receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof e0) {
                s1 N0 = ((e0) receiver).N0();
                if (N0 instanceof m0) {
                    return (m0) N0;
                }
                return null;
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static Collection h0(b bVar, jp.j receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            jp.m d10 = bVar.d(receiver);
            if (d10 instanceof vo.n) {
                return ((vo.n) d10).e();
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.l i(b bVar, jp.i receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof e0) {
                return kp.a.a((e0) receiver);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.l i0(b bVar, jp.c receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof j) {
                return ((j) receiver).getProjection();
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.j j(b bVar, jp.j type, jp.b status) {
            kotlin.jvm.internal.t.g(type, "type");
            kotlin.jvm.internal.t.g(status, "status");
            if (type instanceof m0) {
                return k.b((m0) type, status);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + type + ", " + p0.b(type.getClass())).toString());
        }

        /* JADX WARN: Multi-variable type inference failed */
        public static c1.c j0(b bVar, jp.j type) {
            kotlin.jvm.internal.t.g(type, "type");
            if (type instanceof m0) {
                return new C0571a(bVar, hp.e1.f21918c.a((e0) type).c());
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + type + ", " + p0.b(type.getClass())).toString());
        }

        public static jp.b k(b bVar, jp.d receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof i) {
                return ((i) receiver).T0();
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static Collection k0(b bVar, jp.m receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof d1) {
                Collection n10 = ((d1) receiver).n();
                kotlin.jvm.internal.t.f(n10, "getSupertypes(...)");
                return n10;
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.i l(b bVar, jp.j lowerBound, jp.j upperBound) {
            kotlin.jvm.internal.t.g(lowerBound, "lowerBound");
            kotlin.jvm.internal.t.g(upperBound, "upperBound");
            if (!(lowerBound instanceof m0)) {
                throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + bVar + ", " + p0.b(bVar.getClass())).toString());
            }
            if (upperBound instanceof m0) {
                return f0.d((m0) lowerBound, (m0) upperBound);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + bVar + ", " + p0.b(bVar.getClass())).toString());
        }

        public static jp.c l0(b bVar, jp.d receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof i) {
                return ((i) receiver).K0();
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.l m(b bVar, jp.i receiver, int i10) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof e0) {
                return (jp.l) ((e0) receiver).I0().get(i10);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.m m0(b bVar, jp.j receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof m0) {
                return ((m0) receiver).K0();
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static List n(b bVar, jp.i receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof e0) {
                return ((e0) receiver).I0();
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.j n0(b bVar, jp.g receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof y) {
                return ((y) receiver).T0();
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static ro.d o(b bVar, jp.m receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof d1) {
                tn.h p10 = ((d1) receiver).p();
                kotlin.jvm.internal.t.e(p10, "null cannot be cast to non-null type org.jetbrains.kotlin.descriptors.ClassDescriptor");
                return xo.c.m((tn.e) p10);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.i o0(b bVar, jp.i receiver, boolean z10) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof jp.j) {
                return bVar.g((jp.j) receiver, z10);
            }
            if (!(receiver instanceof jp.g)) {
                throw new IllegalStateException("sealed".toString());
            }
            jp.g gVar = (jp.g) receiver;
            return bVar.m(bVar.g(bVar.f(gVar), z10), bVar.g(bVar.b(gVar), z10));
        }

        public static jp.n p(b bVar, jp.m receiver, int i10) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof d1) {
                Object obj = ((d1) receiver).getParameters().get(i10);
                kotlin.jvm.internal.t.f(obj, "get(...)");
                return (jp.n) obj;
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.j p0(b bVar, jp.j receiver, boolean z10) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof m0) {
                return ((m0) receiver).O0(z10);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static List q(b bVar, jp.m receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof d1) {
                List parameters = ((d1) receiver).getParameters();
                kotlin.jvm.internal.t.f(parameters, "getParameters(...)");
                return parameters;
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static qn.h r(b bVar, jp.m receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof d1) {
                tn.h p10 = ((d1) receiver).p();
                kotlin.jvm.internal.t.e(p10, "null cannot be cast to non-null type org.jetbrains.kotlin.descriptors.ClassDescriptor");
                return qn.g.P((tn.e) p10);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static qn.h s(b bVar, jp.m receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof d1) {
                tn.h p10 = ((d1) receiver).p();
                kotlin.jvm.internal.t.e(p10, "null cannot be cast to non-null type org.jetbrains.kotlin.descriptors.ClassDescriptor");
                return qn.g.S((tn.e) p10);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.i t(b bVar, jp.n receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof e1) {
                return kp.a.j((e1) receiver);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.i u(b bVar, jp.l receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof h1) {
                return ((h1) receiver).getType().N0();
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.n v(b bVar, jp.m receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof d1) {
                tn.h p10 = ((d1) receiver).p();
                if (p10 instanceof e1) {
                    return (e1) p10;
                }
                return null;
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.i w(b bVar, jp.i receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof e0) {
                return to.h.k((e0) receiver);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static List x(b bVar, jp.n receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof e1) {
                List upperBounds = ((e1) receiver).getUpperBounds();
                kotlin.jvm.internal.t.f(upperBounds, "getUpperBounds(...)");
                return upperBounds;
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.s y(b bVar, jp.l receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof h1) {
                t1 a10 = ((h1) receiver).a();
                kotlin.jvm.internal.t.f(a10, "getProjectionKind(...)");
                return jp.p.a(a10);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }

        public static jp.s z(b bVar, jp.n receiver) {
            kotlin.jvm.internal.t.g(receiver, "$receiver");
            if (receiver instanceof e1) {
                t1 l10 = ((e1) receiver).l();
                kotlin.jvm.internal.t.f(l10, "getVariance(...)");
                return jp.p.a(l10);
            }
            throw new IllegalArgumentException(("ClassicTypeSystemContext couldn't handle: " + receiver + ", " + p0.b(receiver.getClass())).toString());
        }
    }

    @Override // jp.o
    jp.d a(jp.j jVar);

    @Override // jp.o
    jp.j b(jp.g gVar);

    @Override // jp.o
    jp.j c(jp.i iVar);

    @Override // jp.o
    jp.m d(jp.j jVar);

    @Override // jp.o
    boolean e(jp.j jVar);

    @Override // jp.o
    jp.j f(jp.g gVar);

    @Override // jp.o
    jp.j g(jp.j jVar, boolean z10);

    jp.i m(jp.j jVar, jp.j jVar2);
}
