package retrofit2;

import android.os.SystemClock;
import android.text.TextUtils;
import android.util.TypedValue;
import android.view.View;
import android.widget.ExpandableListView;
import com.airbnb.deeplinkdispatch.UrlTreeKt;
import com.google.android.gms.maps.model.BitmapDescriptorFactory;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Array;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.WildcardType;
import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.Objects;
import o.C15111ghZ;
import o.GuL;
import o.xzZ;
import okhttp3.HttpUrl;
import okhttp3.ResponseBody;
import org.bouncycastle.crypto.tls.CipherSuite;

/* JADX INFO: Access modifiers changed from: package-private */
/* loaded from: classes.dex */
public final class Utils {
    static final Type[] EMPTY_TYPE_ARRAY;
    private static int b;
    private static long e;
    private static final byte[] $$a = {85, -61, 49, 80};
    private static final int $$b = CipherSuite.TLS_DHE_DSS_WITH_AES_128_GCM_SHA256;
    private static int $10 = 0;
    private static int $11 = 1;
    private static int c = 0;

    /* JADX WARN: Removed duplicated region for block: B:10:0x0028  */
    /* JADX WARN: Removed duplicated region for block: B:7:0x0020  */
    /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:10:0x0028 -> B:4:0x002a). Please report as a decompilation issue!!! */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    private static void f(int r5, short r6, byte r7, java.lang.Object[] r8) {
        /*
            int r5 = r5 * 2
            int r0 = 1 - r5
            int r6 = r6 * 4
            int r6 = r6 + 4
            int r7 = r7 * 2
            int r7 = r7 + 119
            byte[] r1 = retrofit2.Utils.$$a
            byte[] r0 = new byte[r0]
            r2 = 0
            int r5 = 0 - r5
            if (r1 != 0) goto L18
            r3 = r5
            r4 = r2
            goto L2a
        L18:
            r3 = r2
        L19:
            byte r4 = (byte) r7
            r0[r3] = r4
            int r4 = r3 + 1
            if (r3 != r5) goto L28
            java.lang.String r5 = new java.lang.String
            r5.<init>(r0, r2)
            r8[r2] = r5
            return
        L28:
            r3 = r1[r6]
        L2a:
            int r6 = r6 + 1
            int r3 = -r3
            int r7 = r7 + r3
            r3 = r4
            goto L19
        */
        throw new UnsupportedOperationException("Method not decompiled: retrofit2.Utils.f(int, short, byte, java.lang.Object[]):void");
    }

    private Utils() {
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public static RuntimeException methodError(Method method, String str, Object... objArr) {
        int i = 2 % 2;
        int i2 = c + 53;
        b = i2 % 128;
        int i3 = i2 % 2;
        RuntimeException methodError = methodError(method, null, str, objArr);
        if (i3 == 0) {
            int i4 = 66 / 0;
        }
        return methodError;
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public static RuntimeException methodError(Method method, Throwable th, String str, Object... objArr) {
        int i = 2 % 2;
        String format = String.format(str, objArr);
        StringBuilder sb = new StringBuilder();
        sb.append(format);
        sb.append("\n    for method ");
        sb.append(method.getDeclaringClass().getSimpleName());
        sb.append(".");
        sb.append(method.getName());
        IllegalArgumentException illegalArgumentException = new IllegalArgumentException(sb.toString(), th);
        int i2 = c + 7;
        b = i2 % 128;
        int i3 = i2 % 2;
        return illegalArgumentException;
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public static RuntimeException parameterError(Method method, Throwable th, int i, String str, Object... objArr) {
        int i2 = 2 % 2;
        StringBuilder sb = new StringBuilder();
        sb.append(str);
        sb.append(" (parameter #");
        sb.append(i + 1);
        sb.append(")");
        RuntimeException methodError = methodError(method, th, sb.toString(), objArr);
        int i3 = b + 1;
        c = i3 % 128;
        if (i3 % 2 == 0) {
            return methodError;
        }
        Object obj = null;
        obj.hashCode();
        throw null;
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public static RuntimeException parameterError(Method method, int i, String str, Object... objArr) {
        int i2 = 2 % 2;
        StringBuilder sb = new StringBuilder();
        sb.append(str);
        sb.append(" (parameter #");
        sb.append(i + 1);
        sb.append(")");
        RuntimeException methodError = methodError(method, sb.toString(), objArr);
        int i3 = b + 103;
        c = i3 % 128;
        if (i3 % 2 == 0) {
            return methodError;
        }
        throw null;
    }

    private static void d(char[] cArr, int i, Object[] objArr) {
        char c2;
        int i2 = 2 % 2;
        GuL guL = new GuL();
        char[] a = GuL.a(e ^ (-7538262848231253921L), cArr, i);
        int i3 = 4;
        guL.a = 4;
        int i4 = $10 + 5;
        $11 = i4 % 128;
        if (i4 % 2 == 0) {
            int i5 = 5 / 5;
        }
        while (guL.a < a.length) {
            int i6 = $10 + 85;
            $11 = i6 % 128;
            int i7 = i6 % 2;
            guL.c = guL.a - i3;
            int i8 = guL.a;
            try {
                Object[] objArr2 = {Long.valueOf(a[guL.a] ^ a[guL.a % i3]), Long.valueOf(guL.c), Long.valueOf(e)};
                Object obj = xzZ.y.get(428080616);
                if (obj == null) {
                    Class cls = (Class) xzZ.c(208 - View.getDefaultSize(0, 0), (SystemClock.elapsedRealtimeNanos() > 0L ? 1 : (SystemClock.elapsedRealtimeNanos() == 0L ? 0 : -1)) + i3, (char) (TextUtils.indexOf((CharSequence) "", '0', 0, 0) + 1707));
                    byte b2 = (byte) 0;
                    byte b3 = b2;
                    Object[] objArr3 = new Object[1];
                    f(b2, b3, b3, objArr3);
                    obj = cls.getMethod((String) objArr3[0], Long.TYPE, Long.TYPE, Long.TYPE);
                    xzZ.y.put(428080616, obj);
                }
                a[i8] = ((Character) ((Method) obj).invoke(null, objArr2)).charValue();
                Object[] objArr4 = {guL, guL};
                Object obj2 = xzZ.y.get(-1875914398);
                if (obj2 != null) {
                    c2 = 5;
                } else {
                    c2 = 5;
                    Class cls2 = (Class) xzZ.c(392 - ExpandableListView.getPackedPositionType(0L), 5 - TextUtils.getTrimmedLength(""), (char) View.combineMeasuredStates(0, 0));
                    byte b4 = (byte) 0;
                    byte b5 = b4;
                    Object[] objArr5 = new Object[1];
                    f(b4, b5, (byte) (b5 + 1), objArr5);
                    obj2 = cls2.getMethod((String) objArr5[0], Object.class, Object.class);
                    xzZ.y.put(-1875914398, obj2);
                }
                ((Method) obj2).invoke(null, objArr4);
                i3 = 4;
            } catch (Throwable th) {
                Throwable cause = th.getCause();
                if (cause == null) {
                    throw th;
                }
                throw cause;
            }
        }
        objArr[0] = new String(a, 4, a.length - 4);
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public static Class<?> getRawType(Type type) {
        int i = 2 % 2;
        while (true) {
            Objects.requireNonNull(type, "type == null");
            if (type instanceof Class) {
                int i2 = c + 57;
                b = i2 % 128;
                if (i2 % 2 != 0) {
                    return (Class) type;
                }
                Object obj = null;
                obj.hashCode();
                throw null;
            }
            if (type instanceof ParameterizedType) {
                Type rawType = ((ParameterizedType) type).getRawType();
                if (!(rawType instanceof Class)) {
                    throw new IllegalArgumentException();
                }
                int i3 = b + 9;
                c = i3 % 128;
                int i4 = i3 % 2;
                return (Class) rawType;
            }
            if (type instanceof GenericArrayType) {
                int i5 = c + 119;
                b = i5 % 128;
                int i6 = i5 % 2;
                return Array.newInstance(getRawType(((GenericArrayType) type).getGenericComponentType()), 0).getClass();
            }
            if (type instanceof TypeVariable) {
                int i7 = c + 111;
                b = i7 % 128;
                int i8 = i7 % 2;
                return Object.class;
            }
            if (!(type instanceof WildcardType)) {
                StringBuilder sb = new StringBuilder("Expected a Class, ParameterizedType, or GenericArrayType, but <");
                sb.append(type);
                sb.append("> is of type ");
                sb.append(type.getClass().getName());
                throw new IllegalArgumentException(sb.toString());
            }
            int i9 = c + 99;
            b = i9 % 128;
            int i10 = i9 % 2;
            type = ((WildcardType) type).getUpperBounds()[0];
        }
    }

    static boolean equals(Type type, Type type2) {
        int i = 2 % 2;
        while (type != type2) {
            if (type instanceof Class) {
                return type.equals(type2);
            }
            if (type instanceof ParameterizedType) {
                if (!(type2 instanceof ParameterizedType)) {
                    int i2 = b + 93;
                    c = i2 % 128;
                    int i3 = i2 % 2;
                    return false;
                }
                ParameterizedType parameterizedType = (ParameterizedType) type;
                ParameterizedType parameterizedType2 = (ParameterizedType) type2;
                Type ownerType = parameterizedType.getOwnerType();
                Type ownerType2 = parameterizedType2.getOwnerType();
                return (ownerType == ownerType2 || (ownerType != null && ownerType.equals(ownerType2))) && parameterizedType.getRawType().equals(parameterizedType2.getRawType()) && Arrays.equals(parameterizedType.getActualTypeArguments(), parameterizedType2.getActualTypeArguments());
            }
            if (!(type instanceof GenericArrayType)) {
                if (!(type instanceof WildcardType)) {
                    if (!(type instanceof TypeVariable)) {
                        return false;
                    }
                    int i4 = c + 27;
                    b = i4 % 128;
                    int i5 = i4 % 2;
                    if (!(type2 instanceof TypeVariable)) {
                        return false;
                    }
                    TypeVariable typeVariable = (TypeVariable) type;
                    TypeVariable typeVariable2 = (TypeVariable) type2;
                    return typeVariable.getGenericDeclaration() == typeVariable2.getGenericDeclaration() && typeVariable.getName().equals(typeVariable2.getName());
                }
                int i6 = c;
                int i7 = i6 + 33;
                b = i7 % 128;
                int i8 = i7 % 2;
                if (type2 instanceof WildcardType) {
                    WildcardType wildcardType = (WildcardType) type;
                    WildcardType wildcardType2 = (WildcardType) type2;
                    return Arrays.equals(wildcardType.getUpperBounds(), wildcardType2.getUpperBounds()) && Arrays.equals(wildcardType.getLowerBounds(), wildcardType2.getLowerBounds());
                }
                int i9 = i6 + 41;
                b = i9 % 128;
                int i10 = i9 % 2;
                return false;
            }
            int i11 = b + 121;
            c = i11 % 128;
            if (i11 % 2 != 0) {
                boolean z = type2 instanceof GenericArrayType;
                throw null;
            }
            if (!(type2 instanceof GenericArrayType)) {
                return false;
            }
            type = ((GenericArrayType) type).getGenericComponentType();
            type2 = ((GenericArrayType) type2).getGenericComponentType();
        }
        return true;
    }

    static Type getGenericSupertype(Type type, Class<?> cls, Class<?> cls2) {
        Class<?> superclass;
        Type genericSuperclass;
        Class<?>[] interfaces;
        int length;
        int i;
        int i2 = 2 % 2;
        loop0: while (true) {
            Object obj = null;
            if (cls2 != cls) {
                if (cls2.isInterface()) {
                    int i3 = c + 113;
                    b = i3 % 128;
                    if (i3 % 2 == 0) {
                        interfaces = cls.getInterfaces();
                        length = interfaces.length;
                        i = 1;
                    } else {
                        interfaces = cls.getInterfaces();
                        length = interfaces.length;
                        i = 0;
                    }
                    while (i < length) {
                        int i4 = c + 93;
                        b = i4 % 128;
                        int i5 = i4 % 2;
                        Class<?> cls3 = interfaces[i];
                        if (cls3 == cls2) {
                            Type type2 = cls.getGenericInterfaces()[i];
                            int i6 = b + 9;
                            c = i6 % 128;
                            if (i6 % 2 == 0) {
                                return type2;
                            }
                            obj.hashCode();
                            throw null;
                        }
                        if (cls2.isAssignableFrom(cls3)) {
                            genericSuperclass = cls.getGenericInterfaces()[i];
                            superclass = interfaces[i];
                            int i7 = b + 35;
                            c = i7 % 128;
                            int i8 = i7 % 2;
                            break;
                        }
                        i++;
                    }
                }
                if (!cls.isInterface()) {
                    while (cls != Object.class) {
                        superclass = cls.getSuperclass();
                        if (superclass == cls2) {
                            return cls.getGenericSuperclass();
                        }
                        if (cls2.isAssignableFrom(superclass)) {
                            genericSuperclass = cls.getGenericSuperclass();
                            Type type3 = genericSuperclass;
                            cls = superclass;
                            type = type3;
                        } else {
                            cls = superclass;
                        }
                    }
                    break loop0;
                }
                break;
            }
            int i9 = b + 125;
            c = i9 % 128;
            if (i9 % 2 == 0) {
                return type;
            }
            obj.hashCode();
            throw null;
        }
        return cls2;
    }

    private static int indexOf(Object[] objArr, Object obj) {
        int i = 2 % 2;
        int i2 = c;
        int i3 = i2 + 41;
        b = i3 % 128;
        int i4 = i3 % 2;
        int i5 = i2 + 85;
        b = i5 % 128;
        if (i5 % 2 == 0) {
            int i6 = 4 / 4;
        }
        for (int i7 = 0; i7 < objArr.length; i7++) {
            if (obj.equals(objArr[i7])) {
                return i7;
            }
        }
        throw new NoSuchElementException();
    }

    static String typeToString(Type type) {
        int i = 2 % 2;
        if (type instanceof Class) {
            int i2 = b + 119;
            c = i2 % 128;
            int i3 = i2 % 2;
            return ((Class) type).getName();
        }
        String obj = type.toString();
        int i4 = c + 51;
        b = i4 % 128;
        int i5 = i4 % 2;
        return obj;
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public static Type getSupertype(Type type, Class<?> cls, Class<?> cls2) {
        int i = 2 % 2;
        if (!cls2.isAssignableFrom(cls)) {
            throw new IllegalArgumentException();
        }
        int i2 = c + 17;
        b = i2 % 128;
        int i3 = i2 % 2;
        Type resolve = resolve(type, cls, getGenericSupertype(type, cls, cls2));
        int i4 = b + 111;
        c = i4 % 128;
        if (i4 % 2 != 0) {
            int i5 = 99 / 0;
        }
        return resolve;
    }

    static Type resolve(Type type, Class<?> cls, Type type2) {
        int i = 2 % 2;
        Type type3 = type2;
        while (type3 instanceof TypeVariable) {
            TypeVariable typeVariable = (TypeVariable) type3;
            Type resolveTypeVariable = resolveTypeVariable(type, cls, typeVariable);
            if (resolveTypeVariable == typeVariable) {
                return resolveTypeVariable;
            }
            type3 = resolveTypeVariable;
        }
        if (type3 instanceof Class) {
            Class cls2 = (Class) type3;
            if (cls2.isArray()) {
                Class<?> componentType = cls2.getComponentType();
                Type resolve = resolve(type, cls, componentType);
                return componentType == resolve ? cls2 : new GenericArrayTypeImpl(resolve);
            }
        }
        if (type3 instanceof GenericArrayType) {
            GenericArrayType genericArrayType = (GenericArrayType) type3;
            Type genericComponentType = genericArrayType.getGenericComponentType();
            Type resolve2 = resolve(type, cls, genericComponentType);
            if (genericComponentType != resolve2) {
                return new GenericArrayTypeImpl(resolve2);
            }
            int i2 = b + 11;
            c = i2 % 128;
            if (i2 % 2 == 0) {
                return genericArrayType;
            }
            throw null;
        }
        if (type3 instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) type3;
            Type ownerType = parameterizedType.getOwnerType();
            Type resolve3 = resolve(type, cls, ownerType);
            boolean z = resolve3 != ownerType;
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            int length = actualTypeArguments.length;
            for (int i3 = 0; i3 < length; i3++) {
                Type resolve4 = resolve(type, cls, actualTypeArguments[i3]);
                if (resolve4 != actualTypeArguments[i3]) {
                    if (!z) {
                        actualTypeArguments = (Type[]) actualTypeArguments.clone();
                        z = true;
                    }
                    actualTypeArguments[i3] = resolve4;
                    int i4 = c + 39;
                    b = i4 % 128;
                    int i5 = i4 % 2;
                }
            }
            return z ? new ParameterizedTypeImpl(resolve3, parameterizedType.getRawType(), actualTypeArguments) : parameterizedType;
        }
        boolean z2 = type3 instanceof WildcardType;
        Type type4 = type3;
        if (z2) {
            WildcardType wildcardType = (WildcardType) type3;
            Type[] lowerBounds = wildcardType.getLowerBounds();
            Type[] upperBounds = wildcardType.getUpperBounds();
            if (lowerBounds.length == 1) {
                Type resolve5 = resolve(type, cls, lowerBounds[0]);
                type4 = wildcardType;
                if (resolve5 != lowerBounds[0]) {
                    return new WildcardTypeImpl(new Type[]{Object.class}, new Type[]{resolve5});
                }
            } else {
                type4 = wildcardType;
                if (upperBounds.length == 1) {
                    int i6 = b + 83;
                    c = i6 % 128;
                    int i7 = i6 % 2;
                    Type resolve6 = resolve(type, cls, upperBounds[0]);
                    type4 = wildcardType;
                    if (resolve6 != upperBounds[0]) {
                        return new WildcardTypeImpl(new Type[]{resolve6}, EMPTY_TYPE_ARRAY);
                    }
                }
            }
        }
        return type4;
    }

    private static Type resolveTypeVariable(Type type, Class<?> cls, TypeVariable<?> typeVariable) {
        int i = 2 % 2;
        Class<?> declaringClassOf = declaringClassOf(typeVariable);
        if (declaringClassOf == null) {
            return typeVariable;
        }
        Type genericSupertype = getGenericSupertype(type, cls, declaringClassOf);
        if (!(genericSupertype instanceof ParameterizedType)) {
            return typeVariable;
        }
        int i2 = b + 55;
        c = i2 % 128;
        int i3 = i2 % 2;
        Type type2 = ((ParameterizedType) genericSupertype).getActualTypeArguments()[indexOf(declaringClassOf.getTypeParameters(), typeVariable)];
        int i4 = c + 61;
        b = i4 % 128;
        int i5 = i4 % 2;
        return type2;
    }

    private static Class<?> declaringClassOf(TypeVariable<?> typeVariable) {
        int i = 2 % 2;
        int i2 = b + 13;
        c = i2 % 128;
        int i3 = i2 % 2;
        Object genericDeclaration = typeVariable.getGenericDeclaration();
        if (!(genericDeclaration instanceof Class)) {
            return null;
        }
        int i4 = b + 117;
        c = i4 % 128;
        int i5 = i4 % 2;
        return (Class) genericDeclaration;
    }

    /* JADX WARN: Code restructure failed: missing block: B:11:0x0029, code lost:
    
        throw new java.lang.IllegalArgumentException();
     */
    /* JADX WARN: Code restructure failed: missing block: B:13:0x0019, code lost:
    
        if ((r3 instanceof java.lang.Class) != false) goto L9;
     */
    /* JADX WARN: Code restructure failed: missing block: B:4:0x0014, code lost:
    
        if ((r3 instanceof java.lang.Class) != false) goto L9;
     */
    /* JADX WARN: Code restructure failed: missing block: B:9:0x0021, code lost:
    
        if (((java.lang.Class) r3).isPrimitive() != false) goto L12;
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    static void checkNotPrimitive(java.lang.reflect.Type r3) {
        /*
            r0 = 2
            int r1 = r0 % r0
            int r1 = retrofit2.Utils.b
            int r1 = r1 + 63
            int r2 = r1 % 128
            retrofit2.Utils.c = r2
            int r1 = r1 % r0
            if (r1 == 0) goto L17
            boolean r1 = r3 instanceof java.lang.Class
            r2 = 71
            int r2 = r2 / 0
            if (r1 == 0) goto L2a
            goto L1b
        L17:
            boolean r1 = r3 instanceof java.lang.Class
            if (r1 == 0) goto L2a
        L1b:
            java.lang.Class r3 = (java.lang.Class) r3
            boolean r3 = r3.isPrimitive()
            if (r3 != 0) goto L24
            goto L2a
        L24:
            java.lang.IllegalArgumentException r3 = new java.lang.IllegalArgumentException
            r3.<init>()
            throw r3
        L2a:
            int r3 = retrofit2.Utils.c
            int r3 = r3 + 15
            int r1 = r3 % 128
            retrofit2.Utils.b = r1
            int r3 = r3 % r0
            return
        */
        throw new UnsupportedOperationException("Method not decompiled: retrofit2.Utils.checkNotPrimitive(java.lang.reflect.Type):void");
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public static boolean isAnnotationPresent(Annotation[] annotationArr, Class<? extends Annotation> cls) {
        int i = 2 % 2;
        int length = annotationArr.length;
        int i2 = c + 121;
        b = i2 % 128;
        int i3 = i2 % 2;
        for (int i4 = 0; i4 < length; i4++) {
            int i5 = b + 63;
            c = i5 % 128;
            if (i5 % 2 != 0) {
                int i6 = 70 / 0;
                if (cls.isInstance(annotationArr[i4])) {
                    return true;
                }
            } else if (cls.isInstance(annotationArr[i4])) {
                return true;
            }
        }
        int i7 = c + 49;
        b = i7 % 128;
        if (i7 % 2 != 0) {
            return false;
        }
        throw null;
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public static ResponseBody buffer(ResponseBody responseBody) throws IOException {
        int i = 2 % 2;
        C15111ghZ c15111ghZ = new C15111ghZ();
        responseBody.source().d(c15111ghZ);
        ResponseBody create = ResponseBody.create(responseBody.contentType(), responseBody.contentLength(), c15111ghZ);
        int i2 = b + 45;
        c = i2 % 128;
        int i3 = i2 % 2;
        return create;
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public static Type getParameterUpperBound(int i, ParameterizedType parameterizedType) {
        int i2 = 2 % 2;
        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
        if (i >= 0) {
            int i3 = c;
            int i4 = i3 + 43;
            b = i4 % 128;
            int i5 = i4 % 2;
            if (i < actualTypeArguments.length) {
                Type type = actualTypeArguments[i];
                if (!(type instanceof WildcardType)) {
                    return type;
                }
                int i6 = i3 + 109;
                b = i6 % 128;
                return i6 % 2 == 0 ? ((WildcardType) type).getUpperBounds()[0] : ((WildcardType) type).getUpperBounds()[0];
            }
        }
        StringBuilder sb = new StringBuilder("Index ");
        sb.append(i);
        sb.append(" not in range [0,");
        sb.append(actualTypeArguments.length);
        sb.append(") for ");
        sb.append(parameterizedType);
        throw new IllegalArgumentException(sb.toString());
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public static Type getParameterLowerBound(int i, ParameterizedType parameterizedType) {
        int i2 = 2 % 2;
        int i3 = b + 39;
        c = i3 % 128;
        int i4 = i3 % 2;
        Type type = parameterizedType.getActualTypeArguments()[i];
        if (type instanceof WildcardType) {
            int i5 = b + 19;
            c = i5 % 128;
            int i6 = i5 % 2;
            Type[] lowerBounds = ((WildcardType) type).getLowerBounds();
            type = i6 != 0 ? lowerBounds[0] : lowerBounds[0];
        }
        int i7 = b + 87;
        c = i7 % 128;
        int i8 = i7 % 2;
        return type;
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public static boolean hasUnresolvableType(Type type) {
        String name;
        int i = 2 % 2;
        while (true) {
            if (type instanceof Class) {
                return false;
            }
            if (type instanceof ParameterizedType) {
                Type[] actualTypeArguments = ((ParameterizedType) type).getActualTypeArguments();
                int i2 = c + 121;
                b = i2 % 128;
                int i3 = i2 % 2;
                for (Type type2 : actualTypeArguments) {
                    if (hasUnresolvableType(type2)) {
                        int i4 = b + 25;
                        c = i4 % 128;
                        return !(i4 % 2 != 0);
                    }
                }
                return false;
            }
            if (!(type instanceof GenericArrayType)) {
                if (type instanceof TypeVariable) {
                    return true;
                }
                if (type instanceof WildcardType) {
                    int i5 = b + 59;
                    c = i5 % 128;
                    int i6 = i5 % 2;
                    return true;
                }
                if (type == null) {
                    int i7 = b + 123;
                    c = i7 % 128;
                    int i8 = i7 % 2;
                    Object[] objArr = new Object[1];
                    d(new char[]{55736, 55766, 7604, 2663, 5165, 7712, 3529, 8162}, 1 - (TypedValue.complexToFraction(0, BitmapDescriptorFactory.HUE_RED, BitmapDescriptorFactory.HUE_RED) > BitmapDescriptorFactory.HUE_RED ? 1 : (TypedValue.complexToFraction(0, BitmapDescriptorFactory.HUE_RED, BitmapDescriptorFactory.HUE_RED) == BitmapDescriptorFactory.HUE_RED ? 0 : -1)), objArr);
                    name = ((String) objArr[0]).intern();
                } else {
                    name = type.getClass().getName();
                }
                StringBuilder sb = new StringBuilder("Expected a Class, ParameterizedType, or GenericArrayType, but <");
                sb.append(type);
                sb.append("> is of type ");
                sb.append(name);
                throw new IllegalArgumentException(sb.toString());
            }
            type = ((GenericArrayType) type).getGenericComponentType();
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes.dex */
    public static final class ParameterizedTypeImpl implements ParameterizedType {
        private final Type ownerType;
        private final Type rawType;
        private final Type[] typeArguments;

        /* JADX INFO: Access modifiers changed from: package-private */
        public ParameterizedTypeImpl(Type type, Type type2, Type... typeArr) {
            if (type2 instanceof Class) {
                if ((type == null) != (((Class) type2).getEnclosingClass() == null)) {
                    throw new IllegalArgumentException();
                }
            }
            for (Type type3 : typeArr) {
                Objects.requireNonNull(type3, "typeArgument == null");
                Utils.checkNotPrimitive(type3);
            }
            this.ownerType = type;
            this.rawType = type2;
            this.typeArguments = (Type[]) typeArr.clone();
        }

        @Override // java.lang.reflect.ParameterizedType
        public final Type[] getActualTypeArguments() {
            return (Type[]) this.typeArguments.clone();
        }

        public final boolean equals(Object obj) {
            return (obj instanceof ParameterizedType) && Utils.equals(this, (ParameterizedType) obj);
        }

        public final int hashCode() {
            int hashCode = Arrays.hashCode(this.typeArguments);
            int hashCode2 = this.rawType.hashCode();
            Type type = this.ownerType;
            return (hashCode ^ hashCode2) ^ (type != null ? type.hashCode() : 0);
        }

        public final String toString() {
            Type[] typeArr = this.typeArguments;
            if (typeArr.length == 0) {
                return Utils.typeToString(this.rawType);
            }
            StringBuilder sb = new StringBuilder((typeArr.length + 1) * 30);
            sb.append(Utils.typeToString(this.rawType));
            sb.append(UrlTreeKt.configurablePathSegmentPrefix);
            sb.append(Utils.typeToString(this.typeArguments[0]));
            for (int i = 1; i < this.typeArguments.length; i++) {
                sb.append(", ");
                sb.append(Utils.typeToString(this.typeArguments[i]));
            }
            sb.append(UrlTreeKt.configurablePathSegmentSuffix);
            return sb.toString();
        }

        @Override // java.lang.reflect.ParameterizedType
        public final Type getRawType() {
            return this.rawType;
        }

        @Override // java.lang.reflect.ParameterizedType
        public final Type getOwnerType() {
            return this.ownerType;
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes.dex */
    public static final class GenericArrayTypeImpl implements GenericArrayType {
        private final Type componentType;

        GenericArrayTypeImpl(Type type) {
            this.componentType = type;
        }

        public final boolean equals(Object obj) {
            return (obj instanceof GenericArrayType) && Utils.equals(this, (GenericArrayType) obj);
        }

        public final int hashCode() {
            return this.componentType.hashCode();
        }

        public final String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(Utils.typeToString(this.componentType));
            sb.append(HttpUrl.PATH_SEGMENT_ENCODE_SET_URI);
            return sb.toString();
        }

        @Override // java.lang.reflect.GenericArrayType
        public final Type getGenericComponentType() {
            return this.componentType;
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes.dex */
    public static final class WildcardTypeImpl implements WildcardType {
        private final Type lowerBound;
        private final Type upperBound;

        WildcardTypeImpl(Type[] typeArr, Type[] typeArr2) {
            if (typeArr2.length > 1) {
                throw new IllegalArgumentException();
            }
            if (typeArr.length != 1) {
                throw new IllegalArgumentException();
            }
            if (typeArr2.length == 1) {
                Utils.checkNotPrimitive(typeArr2[0]);
                if (typeArr[0] != Object.class) {
                    throw new IllegalArgumentException();
                }
                this.lowerBound = typeArr2[0];
                this.upperBound = Object.class;
                return;
            }
            Utils.checkNotPrimitive(typeArr[0]);
            this.lowerBound = null;
            this.upperBound = typeArr[0];
        }

        @Override // java.lang.reflect.WildcardType
        public final Type[] getLowerBounds() {
            Type type = this.lowerBound;
            return type != null ? new Type[]{type} : Utils.EMPTY_TYPE_ARRAY;
        }

        public final boolean equals(Object obj) {
            return (obj instanceof WildcardType) && Utils.equals(this, (WildcardType) obj);
        }

        public final int hashCode() {
            Type type = this.lowerBound;
            return (type != null ? type.hashCode() + 31 : 1) ^ (this.upperBound.hashCode() + 31);
        }

        public final String toString() {
            if (this.lowerBound != null) {
                StringBuilder sb = new StringBuilder("? super ");
                sb.append(Utils.typeToString(this.lowerBound));
                return sb.toString();
            }
            if (this.upperBound == Object.class) {
                return "?";
            }
            StringBuilder sb2 = new StringBuilder("? extends ");
            sb2.append(Utils.typeToString(this.upperBound));
            return sb2.toString();
        }

        @Override // java.lang.reflect.WildcardType
        public final Type[] getUpperBounds() {
            return new Type[]{this.upperBound};
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public static void throwIfFatal(Throwable th) {
        int i = 2 % 2;
        int i2 = c + 57;
        int i3 = i2 % 128;
        b = i3;
        int i4 = i2 % 2;
        if (th instanceof VirtualMachineError) {
            throw ((VirtualMachineError) th);
        }
        int i5 = i3 + 73;
        c = i5 % 128;
        Object obj = null;
        if (i5 % 2 != 0) {
            boolean z = th instanceof ThreadDeath;
            throw null;
        }
        if (th instanceof ThreadDeath) {
            throw ((ThreadDeath) th);
        }
        if (th instanceof LinkageError) {
            throw ((LinkageError) th);
        }
        int i6 = i3 + 3;
        c = i6 % 128;
        if (i6 % 2 == 0) {
            return;
        }
        obj.hashCode();
        throw null;
    }

    static void b() {
        e = -1076505396678239298L;
    }

    static {
        b = 1;
        b();
        EMPTY_TYPE_ARRAY = new Type[0];
        int i = c + 103;
        b = i % 128;
        if (i % 2 == 0) {
            throw null;
        }
    }
}