package com.facetec.sdk;

import android.graphics.Color;
import android.graphics.ImageFormat;
import android.graphics.PointF;
import android.media.AudioTrack;
import android.os.Process;
import android.os.SystemClock;
import android.view.KeyEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.widget.ExpandableListView;
import com.airbnb.deeplinkdispatch.UrlTreeKt;
import com.google.android.gms.maps.model.BitmapDescriptorFactory;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
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.Collection;
import java.util.HashSet;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Properties;
import o.TVH;
import o.xzZ;
import okhttp3.HttpUrl;
import org.jmrtd.PassportService;

/* loaded from: classes.dex */
public final class et {
    private static final byte[] $$a = {55, -23, -33, -19};
    private static final int $$b = 241;
    private static int $10 = 0;
    private static int $11 = 1;
    private static int a = 0;
    private static char[] b;
    private static int d;
    static final Type[] e;

    private static void i(byte b2, byte b3, int i, Object[] objArr) {
        int i2 = (i * 2) + 71;
        int i3 = b3 * 3;
        byte[] bArr = $$a;
        int i4 = (b2 * 3) + 4;
        byte[] bArr2 = new byte[i3 + 1];
        int i5 = -1;
        if (bArr == null) {
            i2 += -i3;
            i4++;
        }
        while (true) {
            i5++;
            bArr2[i5] = (byte) i2;
            if (i5 == i3) {
                objArr[0] = new String(bArr2, 0);
                return;
            } else {
                i2 += -bArr[i4];
                i4++;
            }
        }
    }

    private static ParameterizedType e(Type type, Type type2, Type... typeArr) {
        int i = 2 % 2;
        b bVar = new b(type, type2, typeArr);
        int i2 = d + 119;
        a = i2 % 128;
        int i3 = i2 % 2;
        return bVar;
    }

    private static GenericArrayType h(Type type) {
        int i = 2 % 2;
        d dVar = new d(type);
        int i2 = a + 91;
        d = i2 % 128;
        int i3 = i2 % 2;
        return dVar;
    }

    /* JADX WARN: Code restructure failed: missing block: B:11:0x001c, code lost:
    
        if ((!(r5 instanceof java.lang.reflect.WildcardType)) != false) goto L9;
     */
    /* JADX WARN: Code restructure failed: missing block: B:4:0x0016, code lost:
    
        if ((!(r5 instanceof java.lang.reflect.WildcardType)) != true) goto L10;
     */
    /* JADX WARN: Code restructure failed: missing block: B:5:0x001e, code lost:
    
        r5 = new java.lang.reflect.Type[]{r5};
        r1 = r1 + 39;
        com.facetec.sdk.et.d = r1 % 128;
        r1 = r1 % 2;
     */
    /* JADX WARN: Code restructure failed: missing block: B:9:0x002a, code lost:
    
        r5 = ((java.lang.reflect.WildcardType) r5).getUpperBounds();
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    private static java.lang.reflect.WildcardType f(java.lang.reflect.Type r5) {
        /*
            r0 = 2
            int r1 = r0 % r0
            int r1 = com.facetec.sdk.et.a
            int r2 = r1 + 55
            int r3 = r2 % 128
            com.facetec.sdk.et.d = r3
            int r2 = r2 % r0
            r3 = 1
            if (r2 != 0) goto L19
            boolean r2 = r5 instanceof java.lang.reflect.WildcardType
            r4 = 87
            int r4 = r4 / 0
            r2 = r2 ^ r3
            if (r2 == r3) goto L1e
            goto L2a
        L19:
            boolean r2 = r5 instanceof java.lang.reflect.WildcardType
            r2 = r2 ^ r3
            if (r2 == 0) goto L2a
        L1e:
            java.lang.reflect.Type[] r5 = new java.lang.reflect.Type[]{r5}
            int r1 = r1 + 39
            int r2 = r1 % 128
            com.facetec.sdk.et.d = r2
            int r1 = r1 % r0
            goto L30
        L2a:
            java.lang.reflect.WildcardType r5 = (java.lang.reflect.WildcardType) r5
            java.lang.reflect.Type[] r5 = r5.getUpperBounds()
        L30:
            com.facetec.sdk.et$a r1 = new com.facetec.sdk.et$a
            java.lang.reflect.Type[] r2 = com.facetec.sdk.et.e
            r1.<init>(r5, r2)
            int r5 = com.facetec.sdk.et.d
            int r5 = r5 + 121
            int r2 = r5 % 128
            com.facetec.sdk.et.a = r2
            int r5 = r5 % r0
            return r1
        */
        throw new UnsupportedOperationException("Method not decompiled: com.facetec.sdk.et.f(java.lang.reflect.Type):java.lang.reflect.WildcardType");
    }

    private static WildcardType j(Type type) {
        Type[] typeArr;
        int i = 2 % 2;
        if (type instanceof WildcardType) {
            int i2 = a + 93;
            d = i2 % 128;
            int i3 = i2 % 2;
            typeArr = ((WildcardType) type).getLowerBounds();
        } else {
            typeArr = new Type[]{type};
        }
        a aVar = new a(new Type[]{Object.class}, typeArr);
        int i4 = d + 101;
        a = i4 % 128;
        if (i4 % 2 != 0) {
            int i5 = 61 / 0;
        }
        return aVar;
    }

    /* JADX WARN: Code restructure failed: missing block: B:12:0x0037, code lost:
    
        if ((r4 instanceof java.lang.reflect.ParameterizedType) == false) goto L21;
     */
    /* JADX WARN: Code restructure failed: missing block: B:13:0x0039, code lost:
    
        r4 = (java.lang.reflect.ParameterizedType) r4;
        r2 = new com.facetec.sdk.et.b(r4.getOwnerType(), r4.getRawType(), r4.getActualTypeArguments());
        r4 = com.facetec.sdk.et.d + 53;
        com.facetec.sdk.et.a = r4 % 128;
     */
    /* JADX WARN: Code restructure failed: missing block: B:14:0x0055, code lost:
    
        if ((r4 % 2) != 0) goto L19;
     */
    /* JADX WARN: Code restructure failed: missing block: B:15:0x0057, code lost:
    
        return r2;
     */
    /* JADX WARN: Code restructure failed: missing block: B:16:0x0058, code lost:
    
        r4 = null;
        r4.hashCode();
     */
    /* JADX WARN: Code restructure failed: missing block: B:17:0x005c, code lost:
    
        throw null;
     */
    /* JADX WARN: Code restructure failed: missing block: B:19:0x005f, code lost:
    
        if ((r4 instanceof java.lang.reflect.GenericArrayType) == false) goto L25;
     */
    /* JADX WARN: Code restructure failed: missing block: B:21:0x006c, code lost:
    
        return new com.facetec.sdk.et.d(((java.lang.reflect.GenericArrayType) r4).getGenericComponentType());
     */
    /* JADX WARN: Code restructure failed: missing block: B:23:0x006f, code lost:
    
        if ((r4 instanceof java.lang.reflect.WildcardType) == false) goto L29;
     */
    /* JADX WARN: Code restructure failed: missing block: B:24:0x0071, code lost:
    
        r4 = (java.lang.reflect.WildcardType) r4;
     */
    /* JADX WARN: Code restructure failed: missing block: B:25:0x0080, code lost:
    
        return new com.facetec.sdk.et.a(r4.getUpperBounds(), r4.getLowerBounds());
     */
    /* JADX WARN: Code restructure failed: missing block: B:26:0x0081, code lost:
    
        return r4;
     */
    /* JADX WARN: Code restructure failed: missing block: B:28:0x001a, code lost:
    
        if ((r4 instanceof java.lang.Class) != false) goto L9;
     */
    /* JADX WARN: Code restructure failed: missing block: B:4:0x0015, code lost:
    
        if ((r4 instanceof java.lang.Class) != true) goto L14;
     */
    /* JADX WARN: Code restructure failed: missing block: B:5:0x001c, code lost:
    
        r4 = (java.lang.Class) r4;
     */
    /* JADX WARN: Code restructure failed: missing block: B:6:0x0022, code lost:
    
        if (r4.isArray() == false) goto L12;
     */
    /* JADX WARN: Code restructure failed: missing block: B:7:0x0024, code lost:
    
        r4 = new com.facetec.sdk.et.d(c(r4.getComponentType()));
     */
    /* JADX WARN: Code restructure failed: missing block: B:9:0x0034, code lost:
    
        return r4;
     */
    /* JADX WARN: Multi-variable type inference failed */
    /* JADX WARN: Type inference failed for: r0v6, types: [com.facetec.sdk.et$d] */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public static java.lang.reflect.Type c(java.lang.reflect.Type r4) {
        /*
            r0 = 2
            int r1 = r0 % r0
            int r1 = com.facetec.sdk.et.d
            int r1 = r1 + 33
            int r2 = r1 % 128
            com.facetec.sdk.et.a = r2
            int r1 = r1 % r0
            if (r1 == 0) goto L18
            boolean r1 = r4 instanceof java.lang.Class
            r2 = 96
            int r2 = r2 / 0
            r2 = 1
            if (r1 == r2) goto L1c
            goto L35
        L18:
            boolean r1 = r4 instanceof java.lang.Class
            if (r1 == 0) goto L35
        L1c:
            java.lang.Class r4 = (java.lang.Class) r4
            boolean r0 = r4.isArray()
            if (r0 == 0) goto L32
            com.facetec.sdk.et$d r0 = new com.facetec.sdk.et$d
            java.lang.Class r4 = r4.getComponentType()
            java.lang.reflect.Type r4 = c(r4)
            r0.<init>(r4)
            r4 = r0
        L32:
            java.lang.reflect.Type r4 = (java.lang.reflect.Type) r4
            return r4
        L35:
            boolean r1 = r4 instanceof java.lang.reflect.ParameterizedType
            if (r1 == 0) goto L5d
            java.lang.reflect.ParameterizedType r4 = (java.lang.reflect.ParameterizedType) r4
            java.lang.reflect.Type r1 = r4.getOwnerType()
            com.facetec.sdk.et$b r2 = new com.facetec.sdk.et$b
            java.lang.reflect.Type r3 = r4.getRawType()
            java.lang.reflect.Type[] r4 = r4.getActualTypeArguments()
            r2.<init>(r1, r3, r4)
            int r4 = com.facetec.sdk.et.d
            int r4 = r4 + 53
            int r1 = r4 % 128
            com.facetec.sdk.et.a = r1
            int r4 = r4 % r0
            if (r4 != 0) goto L58
            return r2
        L58:
            r4 = 0
            r4.hashCode()
            throw r4
        L5d:
            boolean r0 = r4 instanceof java.lang.reflect.GenericArrayType
            if (r0 == 0) goto L6d
            java.lang.reflect.GenericArrayType r4 = (java.lang.reflect.GenericArrayType) r4
            com.facetec.sdk.et$d r0 = new com.facetec.sdk.et$d
            java.lang.reflect.Type r4 = r4.getGenericComponentType()
            r0.<init>(r4)
            return r0
        L6d:
            boolean r0 = r4 instanceof java.lang.reflect.WildcardType
            if (r0 == 0) goto L81
            java.lang.reflect.WildcardType r4 = (java.lang.reflect.WildcardType) r4
            com.facetec.sdk.et$a r0 = new com.facetec.sdk.et$a
            java.lang.reflect.Type[] r1 = r4.getUpperBounds()
            java.lang.reflect.Type[] r4 = r4.getLowerBounds()
            r0.<init>(r1, r4)
            return r0
        L81:
            return r4
        */
        throw new UnsupportedOperationException("Method not decompiled: com.facetec.sdk.et.c(java.lang.reflect.Type):java.lang.reflect.Type");
    }

    public static Class<?> e(Type type) {
        String name;
        int i = 2 % 2;
        while (!(type instanceof Class)) {
            if (type instanceof ParameterizedType) {
                Type rawType = ((ParameterizedType) type).getRawType();
                er.b(rawType instanceof Class);
                return (Class) rawType;
            }
            if (type instanceof GenericArrayType) {
                Class<?> cls = Array.newInstance(e(((GenericArrayType) type).getGenericComponentType()), 0).getClass();
                int i2 = d + 37;
                a = i2 % 128;
                if (i2 % 2 != 0) {
                    int i3 = 53 / 0;
                }
                return cls;
            }
            if (!(type instanceof TypeVariable)) {
                if (type instanceof WildcardType) {
                    int i4 = a + 95;
                    d = i4 % 128;
                    type = i4 % 2 == 0 ? ((WildcardType) type).getUpperBounds()[0] : ((WildcardType) type).getUpperBounds()[0];
                } else {
                    if (type == null) {
                        int i5 = d + 1;
                        a = i5 % 128;
                        int i6 = i5 % 2;
                        Object[] objArr = new Object[1];
                        g(new byte[]{0, 1, 1, 0}, new int[]{0, 4, 18, 0}, false, 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());
                }
            } else {
                int i7 = d + 89;
                a = i7 % 128;
                if (i7 % 2 == 0) {
                    return Object.class;
                }
                int i8 = 77 / 0;
                return Object.class;
            }
        }
        return (Class) type;
    }

    private static boolean d(Object obj, Object obj2) {
        int i = 2 % 2;
        int i2 = d + 3;
        a = i2 % 128;
        if (i2 % 2 != 0) {
            throw null;
        }
        if (obj != obj2 && (obj == null || !obj.equals(obj2))) {
            return false;
        }
        int i3 = d + 83;
        a = i3 % 128;
        if (i3 % 2 != 0) {
            int i4 = 1 / 0;
        }
        return true;
    }

    public static boolean c(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 = d + 99;
                    a = i2 % 128;
                    int i3 = i2 % 2;
                    return false;
                }
                ParameterizedType parameterizedType = (ParameterizedType) type;
                ParameterizedType parameterizedType2 = (ParameterizedType) type2;
                if (!d(parameterizedType.getOwnerType(), parameterizedType2.getOwnerType()) || !parameterizedType.getRawType().equals(parameterizedType2.getRawType()) || !Arrays.equals(parameterizedType.getActualTypeArguments(), parameterizedType2.getActualTypeArguments())) {
                    return false;
                }
                int i4 = d + 23;
                a = i4 % 128;
                int i5 = i4 % 2;
                return true;
            }
            if (!(type instanceof GenericArrayType)) {
                if (type instanceof WildcardType) {
                    if (!(type2 instanceof WildcardType)) {
                        int i6 = d + 125;
                        a = i6 % 128;
                        int i7 = i6 % 2;
                        return false;
                    }
                    WildcardType wildcardType = (WildcardType) type;
                    WildcardType wildcardType2 = (WildcardType) type2;
                    if (!Arrays.equals(wildcardType.getUpperBounds(), wildcardType2.getUpperBounds()) || !Arrays.equals(wildcardType.getLowerBounds(), wildcardType2.getLowerBounds())) {
                        return false;
                    }
                    int i8 = d + 13;
                    a = i8 % 128;
                    int i9 = i8 % 2;
                    return true;
                }
                if (type instanceof TypeVariable) {
                    int i10 = d + 31;
                    a = i10 % 128;
                    if (i10 % 2 != 0) {
                        boolean z = type2 instanceof TypeVariable;
                        Object obj = null;
                        obj.hashCode();
                        throw null;
                    }
                    if (!(type2 instanceof TypeVariable)) {
                        return false;
                    }
                    TypeVariable typeVariable = (TypeVariable) type;
                    TypeVariable typeVariable2 = (TypeVariable) type2;
                    if (typeVariable.getGenericDeclaration() == typeVariable2.getGenericDeclaration() && typeVariable.getName().equals(typeVariable2.getName())) {
                        int i11 = a + 73;
                        d = i11 % 128;
                        int i12 = i11 % 2;
                        return true;
                    }
                }
                return false;
            }
            int i13 = a + 67;
            int i14 = i13 % 128;
            d = i14;
            int i15 = i13 % 2;
            if (!(type2 instanceof GenericArrayType)) {
                int i16 = i14 + 11;
                a = i16 % 128;
                return i16 % 2 != 0;
            }
            type = ((GenericArrayType) type).getGenericComponentType();
            type2 = ((GenericArrayType) type2).getGenericComponentType();
        }
        int i17 = d + 87;
        a = i17 % 128;
        int i18 = i17 % 2;
        return true;
    }

    private static void g(byte[] bArr, int[] iArr, boolean z, Object[] objArr) {
        int i;
        int i2;
        int i3 = 2;
        int i4 = 2 % 2;
        TVH tvh = new TVH();
        int i5 = 0;
        int i6 = iArr[0];
        int i7 = iArr[1];
        int i8 = iArr[2];
        int i9 = iArr[3];
        char[] cArr = b;
        float f = BitmapDescriptorFactory.HUE_RED;
        if (cArr != null) {
            int length = cArr.length;
            char[] cArr2 = new char[length];
            int i10 = $10 + 13;
            $11 = i10 % 128;
            if (i10 % 2 == 0) {
                int i11 = 4 / 4;
            }
            int i12 = 0;
            while (i12 < length) {
                int i13 = $10 + 21;
                $11 = i13 % 128;
                int i14 = i13 % i3;
                try {
                    Object[] objArr2 = new Object[1];
                    objArr2[i5] = Integer.valueOf(cArr[i12]);
                    Object obj = xzZ.y.get(1645349359);
                    if (obj == null) {
                        Class cls = (Class) xzZ.c(ImageFormat.getBitsPerPixel(i5) + PassportService.DEFAULT_MAX_BLOCKSIZE, (ViewConfiguration.getMaximumFlingVelocity() >> 16) + 5, (char) (41978 - (AudioTrack.getMaxVolume() > f ? 1 : (AudioTrack.getMaxVolume() == f ? 0 : -1))));
                        byte b2 = (byte) i5;
                        byte b3 = b2;
                        Object[] objArr3 = new Object[1];
                        i(b2, b3, b3, objArr3);
                        obj = cls.getMethod((String) objArr3[0], Integer.TYPE);
                        xzZ.y.put(1645349359, obj);
                    }
                    cArr2[i12] = ((Character) ((Method) obj).invoke(null, objArr2)).charValue();
                    i12++;
                    i3 = 2;
                    i5 = 0;
                    f = BitmapDescriptorFactory.HUE_RED;
                } catch (Throwable th) {
                    Throwable cause = th.getCause();
                    if (cause == null) {
                        throw th;
                    }
                    throw cause;
                }
            }
            cArr = cArr2;
        }
        char[] cArr3 = new char[i7];
        System.arraycopy(cArr, i6, cArr3, 0, i7);
        if (bArr != null) {
            char[] cArr4 = new char[i7];
            tvh.c = 0;
            char c = 0;
            while (tvh.c < i7) {
                int i15 = $10 + 73;
                $11 = i15 % 128;
                int i16 = i15 % 2;
                if (bArr[tvh.c] == 1) {
                    int i17 = tvh.c;
                    Object[] objArr4 = {Integer.valueOf(cArr3[tvh.c]), Integer.valueOf(c)};
                    Object obj2 = xzZ.y.get(850398076);
                    if (obj2 == null) {
                        obj2 = ((Class) xzZ.c(502 - (ViewConfiguration.getKeyRepeatDelay() >> 16), (SystemClock.uptimeMillis() > 0L ? 1 : (SystemClock.uptimeMillis() == 0L ? 0 : -1)) + 4, (char) (Color.alpha(0) + 54))).getMethod("F", Integer.TYPE, Integer.TYPE);
                        xzZ.y.put(850398076, obj2);
                    }
                    cArr4[i17] = ((Character) ((Method) obj2).invoke(null, objArr4)).charValue();
                } else {
                    int i18 = tvh.c;
                    Object[] objArr5 = {Integer.valueOf(cArr3[tvh.c]), Integer.valueOf(c)};
                    Object obj3 = xzZ.y.get(1084521042);
                    if (obj3 == null) {
                        obj3 = ((Class) xzZ.c(ExpandableListView.getPackedPositionGroup(0L) + 15, 5 - ExpandableListView.getPackedPositionType(0L), (char) (((Process.getThreadPriority(0) + 20) >> 6) + 58134))).getMethod("H", Integer.TYPE, Integer.TYPE);
                        xzZ.y.put(1084521042, obj3);
                    }
                    cArr4[i18] = ((Character) ((Method) obj3).invoke(null, objArr5)).charValue();
                }
                c = cArr4[tvh.c];
                Object[] objArr6 = {tvh, tvh};
                Object obj4 = xzZ.y.get(1698744941);
                if (obj4 == null) {
                    Class cls2 = (Class) xzZ.c(402 - (KeyEvent.getMaxKeyCode() >> 16), View.MeasureSpec.makeMeasureSpec(0, 0) + 5, (char) ((PointF.length(BitmapDescriptorFactory.HUE_RED, BitmapDescriptorFactory.HUE_RED) > BitmapDescriptorFactory.HUE_RED ? 1 : (PointF.length(BitmapDescriptorFactory.HUE_RED, BitmapDescriptorFactory.HUE_RED) == BitmapDescriptorFactory.HUE_RED ? 0 : -1)) + 21608));
                    byte b4 = (byte) 0;
                    byte b5 = b4;
                    Object[] objArr7 = new Object[1];
                    i(b4, b5, (byte) (b5 + 1), objArr7);
                    obj4 = cls2.getMethod((String) objArr7[0], Object.class, Object.class);
                    xzZ.y.put(1698744941, obj4);
                }
                ((Method) obj4).invoke(null, objArr6);
            }
            cArr3 = cArr4;
        }
        if (i9 > 0) {
            char[] cArr5 = new char[i7];
            i = 0;
            System.arraycopy(cArr3, 0, cArr5, 0, i7);
            int i19 = i7 - i9;
            System.arraycopy(cArr5, 0, cArr3, i19, i9);
            System.arraycopy(cArr5, i9, cArr3, 0, i19);
        } else {
            i = 0;
        }
        if (z) {
            char[] cArr6 = new char[i7];
            tvh.c = i;
            int i20 = $11 + 57;
            $10 = i20 % 128;
            int i21 = i20 % 2;
            while (tvh.c < i7) {
                int i22 = $10 + 89;
                $11 = i22 % 128;
                if (i22 % 2 == 0) {
                    cArr6[tvh.c] = cArr3[tvh.c + i7];
                    i2 = tvh.c;
                } else {
                    cArr6[tvh.c] = cArr3[(i7 - tvh.c) - 1];
                    i2 = tvh.c + 1;
                }
                tvh.c = i2;
            }
            cArr3 = cArr6;
        }
        if (i8 > 0) {
            int i23 = 0;
            while (true) {
                tvh.c = i23;
                if (tvh.c >= i7) {
                    break;
                }
                cArr3[tvh.c] = (char) (cArr3[tvh.c] - iArr[2]);
                i23 = tvh.c + 1;
            }
        }
        objArr[0] = new String(cArr3);
    }

    /* JADX WARN: Code restructure failed: missing block: B:10:0x0015, code lost:
    
        if (r4 != null) goto L8;
     */
    /* JADX WARN: Code restructure failed: missing block: B:4:0x0012, code lost:
    
        if (r4 != null) goto L8;
     */
    /* JADX WARN: Code restructure failed: missing block: B:5:0x0025, code lost:
    
        r1 = r1 + 27;
        com.facetec.sdk.et.d = r1 % 128;
        r1 = r1 % 2;
     */
    /* JADX WARN: Code restructure failed: missing block: B:6:0x002c, code lost:
    
        return 0;
     */
    /* JADX WARN: Code restructure failed: missing block: B:8:0x0017, code lost:
    
        r4 = r4.hashCode();
        r1 = com.facetec.sdk.et.d + 3;
        com.facetec.sdk.et.a = r1 % 128;
        r1 = r1 % 2;
     */
    /* JADX WARN: Code restructure failed: missing block: B:9:0x0024, code lost:
    
        return r4;
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    static int e(java.lang.Object r4) {
        /*
            r0 = 2
            int r1 = r0 % r0
            int r1 = com.facetec.sdk.et.a
            int r2 = r1 + 83
            int r3 = r2 % 128
            com.facetec.sdk.et.d = r3
            int r2 = r2 % r0
            r3 = 0
            if (r2 != 0) goto L15
            r2 = 15
            int r2 = r2 / r3
            if (r4 == 0) goto L25
            goto L17
        L15:
            if (r4 == 0) goto L25
        L17:
            int r4 = r4.hashCode()
            int r1 = com.facetec.sdk.et.d
            int r1 = r1 + 3
            int r2 = r1 % 128
            com.facetec.sdk.et.a = r2
            int r1 = r1 % r0
            return r4
        L25:
            int r1 = r1 + 27
            int r4 = r1 % 128
            com.facetec.sdk.et.d = r4
            int r1 = r1 % r0
            return r3
        */
        throw new UnsupportedOperationException("Method not decompiled: com.facetec.sdk.et.e(java.lang.Object):int");
    }

    public static String b(Type type) {
        int i = 2 % 2;
        int i2 = a + 21;
        d = i2 % 128;
        int i3 = i2 % 2;
        if (!(type instanceof Class)) {
            return type.toString();
        }
        String name = ((Class) type).getName();
        int i4 = a + 11;
        d = i4 % 128;
        if (i4 % 2 == 0) {
            int i5 = 44 / 0;
        }
        return name;
    }

    private static Type e(Type type, Class<?> cls, Class<?> cls2) {
        Class<?> superclass;
        Type genericSuperclass;
        int i = 2 % 2;
        while (cls2 != cls) {
            if (cls2.isInterface()) {
                Class<?>[] interfaces = cls.getInterfaces();
                int length = interfaces.length;
                int i2 = 0;
                while (i2 < length) {
                    if (interfaces[i2] != cls2) {
                        if (!(!cls2.isAssignableFrom(r3))) {
                            int i3 = a + 19;
                            d = i3 % 128;
                            int i4 = i3 % 2;
                            genericSuperclass = cls.getGenericInterfaces()[i2];
                            superclass = interfaces[i2];
                            int i5 = a + 117;
                            d = i5 % 128;
                            int i6 = i5 % 2;
                            break;
                        }
                        i2++;
                        int i7 = d + 81;
                        a = i7 % 128;
                        int i8 = i7 % 2;
                    } else {
                        int i9 = d + 35;
                        a = i9 % 128;
                        if (i9 % 2 == 0) {
                            return cls.getGenericInterfaces()[i2];
                        }
                        Type type2 = cls.getGenericInterfaces()[i2];
                        throw null;
                    }
                }
            }
            if (!cls.isInterface()) {
                int i10 = a + 41;
                d = i10 % 128;
                int i11 = i10 % 2;
                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;
                    }
                }
            }
            return cls2;
        }
        return type;
    }

    private static Type c(Type type, Class<?> cls, Class<?> cls2) {
        int i = 2 % 2;
        if (type instanceof WildcardType) {
            int i2 = a + 107;
            d = i2 % 128;
            int i3 = i2 % 2;
            type = ((WildcardType) type).getUpperBounds()[0];
        }
        er.b(cls2.isAssignableFrom(cls));
        Type e2 = e(type, cls, e(type, cls, cls2));
        int i4 = d + 15;
        a = i4 % 128;
        int i5 = i4 % 2;
        return e2;
    }

    /* JADX WARN: Code restructure failed: missing block: B:10:0x002c, code lost:
    
        ((java.lang.reflect.GenericArrayType) r4).getGenericComponentType();
        r4 = null;
        r4.hashCode();
     */
    /* JADX WARN: Code restructure failed: missing block: B:11:0x0035, code lost:
    
        throw null;
     */
    /* JADX WARN: Code restructure failed: missing block: B:13:0x003c, code lost:
    
        return ((java.lang.Class) r4).getComponentType();
     */
    /* JADX WARN: Code restructure failed: missing block: B:15:0x001a, code lost:
    
        if ((r4 instanceof java.lang.reflect.GenericArrayType) != false) goto L9;
     */
    /* JADX WARN: Code restructure failed: missing block: B:4:0x0015, code lost:
    
        if ((r4 instanceof java.lang.reflect.GenericArrayType) != true) goto L15;
     */
    /* JADX WARN: Code restructure failed: missing block: B:5:0x001c, code lost:
    
        r1 = r1 + 75;
        com.facetec.sdk.et.a = r1 % 128;
     */
    /* JADX WARN: Code restructure failed: missing block: B:6:0x0023, code lost:
    
        if ((r1 % 2) != 0) goto L13;
     */
    /* JADX WARN: Code restructure failed: missing block: B:8:0x002b, code lost:
    
        return ((java.lang.reflect.GenericArrayType) r4).getGenericComponentType();
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public static java.lang.reflect.Type a(java.lang.reflect.Type r4) {
        /*
            r0 = 2
            int r1 = r0 % r0
            int r1 = com.facetec.sdk.et.d
            int r2 = r1 + 79
            int r3 = r2 % 128
            com.facetec.sdk.et.a = r3
            int r2 = r2 % r0
            if (r2 == 0) goto L18
            boolean r2 = r4 instanceof java.lang.reflect.GenericArrayType
            r3 = 92
            int r3 = r3 / 0
            r3 = 1
            if (r2 == r3) goto L1c
            goto L36
        L18:
            boolean r2 = r4 instanceof java.lang.reflect.GenericArrayType
            if (r2 == 0) goto L36
        L1c:
            int r1 = r1 + 75
            int r2 = r1 % 128
            com.facetec.sdk.et.a = r2
            int r1 = r1 % r0
            if (r1 != 0) goto L2c
            java.lang.reflect.GenericArrayType r4 = (java.lang.reflect.GenericArrayType) r4
            java.lang.reflect.Type r4 = r4.getGenericComponentType()
            return r4
        L2c:
            java.lang.reflect.GenericArrayType r4 = (java.lang.reflect.GenericArrayType) r4
            r4.getGenericComponentType()
            r4 = 0
            r4.hashCode()
            throw r4
        L36:
            java.lang.Class r4 = (java.lang.Class) r4
            java.lang.Class r4 = r4.getComponentType()
            return r4
        */
        throw new UnsupportedOperationException("Method not decompiled: com.facetec.sdk.et.a(java.lang.reflect.Type):java.lang.reflect.Type");
    }

    public static Type c(Type type, Class<?> cls) {
        int i = 2 % 2;
        Type c = c(type, cls, Collection.class);
        if (c instanceof WildcardType) {
            c = ((WildcardType) c).getUpperBounds()[0];
            int i2 = a + 13;
            d = i2 % 128;
            int i3 = i2 % 2;
        }
        if (!(c instanceof ParameterizedType)) {
            return Object.class;
        }
        Type type2 = ((ParameterizedType) c).getActualTypeArguments()[0];
        int i4 = d + 39;
        a = i4 % 128;
        if (i4 % 2 == 0) {
            return type2;
        }
        throw null;
    }

    public static Type[] a(Type type, Class<?> cls) {
        int i = 2 % 2;
        if (type == Properties.class) {
            int i2 = a + 35;
            d = i2 % 128;
            int i3 = i2 % 2;
            return new Type[]{String.class, String.class};
        }
        Type c = c(type, cls, Map.class);
        if (!(c instanceof ParameterizedType)) {
            return new Type[]{Object.class, Object.class};
        }
        int i4 = d + 45;
        a = i4 % 128;
        int i5 = i4 % 2;
        return ((ParameterizedType) c).getActualTypeArguments();
    }

    public static Type e(Type type, Class<?> cls, Type type2) {
        int i = 2 % 2;
        Type b2 = b(type, cls, type2, new HashSet());
        int i2 = d + 111;
        a = i2 % 128;
        if (i2 % 2 == 0) {
            return b2;
        }
        Object obj = null;
        obj.hashCode();
        throw null;
    }

    private static Type b(Type type, Class<?> cls, Type type2, Collection<TypeVariable> collection) {
        boolean z;
        TypeVariable typeVariable;
        int i = 2 % 2;
        do {
            Object obj = null;
            if (!(type2 instanceof TypeVariable)) {
                if (type2 instanceof Class) {
                    Class cls2 = (Class) type2;
                    if (cls2.isArray()) {
                        Class<?> componentType = cls2.getComponentType();
                        Type b2 = b(type, cls, componentType, collection);
                        if (componentType != b2) {
                            return h(b2);
                        }
                        int i2 = d + 63;
                        a = i2 % 128;
                        if (i2 % 2 != 0) {
                            int i3 = 9 / 0;
                        }
                        return cls2;
                    }
                }
                if (type2 instanceof GenericArrayType) {
                    int i4 = d + 67;
                    a = i4 % 128;
                    int i5 = i4 % 2;
                    GenericArrayType genericArrayType = (GenericArrayType) type2;
                    Type genericComponentType = genericArrayType.getGenericComponentType();
                    Type b3 = b(type, cls, genericComponentType, collection);
                    if (genericComponentType != b3) {
                        return h(b3);
                    }
                    int i6 = a + 103;
                    d = i6 % 128;
                    int i7 = i6 % 2;
                    return genericArrayType;
                }
                if (!(type2 instanceof ParameterizedType)) {
                    boolean z2 = type2 instanceof WildcardType;
                    Type type3 = type2;
                    if (z2) {
                        WildcardType wildcardType = (WildcardType) type2;
                        Type[] lowerBounds = wildcardType.getLowerBounds();
                        Type[] upperBounds = wildcardType.getUpperBounds();
                        if (lowerBounds.length == 1) {
                            Type b4 = b(type, cls, lowerBounds[0], collection);
                            type3 = wildcardType;
                            if (b4 != lowerBounds[0]) {
                                return j(b4);
                            }
                        } else {
                            type3 = wildcardType;
                            if (upperBounds.length == 1) {
                                Type b5 = b(type, cls, upperBounds[0], collection);
                                type3 = wildcardType;
                                if (b5 != upperBounds[0]) {
                                    int i8 = d + 107;
                                    a = i8 % 128;
                                    int i9 = i8 % 2;
                                    return f(b5);
                                }
                            }
                        }
                    }
                    return type3;
                }
                ParameterizedType parameterizedType = (ParameterizedType) type2;
                Type ownerType = parameterizedType.getOwnerType();
                Type b6 = b(type, cls, ownerType, collection);
                if (b6 != ownerType) {
                    z = true;
                } else {
                    int i10 = d + 81;
                    a = i10 % 128;
                    int i11 = i10 % 2;
                    z = false;
                }
                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                int length = actualTypeArguments.length;
                for (int i12 = 0; i12 < length; i12++) {
                    int i13 = a + 25;
                    d = i13 % 128;
                    if (i13 % 2 == 0) {
                        b(type, cls, actualTypeArguments[i12], collection);
                        Type type4 = actualTypeArguments[i12];
                        throw null;
                    }
                    Type b7 = b(type, cls, actualTypeArguments[i12], collection);
                    if (b7 != actualTypeArguments[i12]) {
                        if (!z) {
                            actualTypeArguments = (Type[]) actualTypeArguments.clone();
                            z = true;
                        }
                        actualTypeArguments[i12] = b7;
                    }
                }
                if (!z) {
                    return parameterizedType;
                }
                int i14 = a + 61;
                d = i14 % 128;
                if (i14 % 2 != 0) {
                    return e(b6, parameterizedType.getRawType(), actualTypeArguments);
                }
                e(b6, parameterizedType.getRawType(), actualTypeArguments);
                obj.hashCode();
                throw null;
            }
            typeVariable = (TypeVariable) type2;
            if (collection.contains(typeVariable)) {
                int i15 = a + 75;
                d = i15 % 128;
                if (i15 % 2 != 0) {
                    return type2;
                }
                obj.hashCode();
                throw null;
            }
            collection.add(typeVariable);
            type2 = a(type, cls, typeVariable);
        } while (type2 != typeVariable);
        return type2;
    }

    private static Type a(Type type, Class<?> cls, TypeVariable<?> typeVariable) {
        int i = 2 % 2;
        Class<?> e2 = e(typeVariable);
        if (e2 == null) {
            return typeVariable;
        }
        Type e3 = e(type, cls, e2);
        if (!(e3 instanceof ParameterizedType)) {
            int i2 = a + 71;
            d = i2 % 128;
            int i3 = i2 % 2;
            return typeVariable;
        }
        int i4 = a + 7;
        d = i4 % 128;
        if (i4 % 2 == 0) {
            Type type2 = ((ParameterizedType) e3).getActualTypeArguments()[a(e2.getTypeParameters(), typeVariable)];
            throw null;
        }
        Type type3 = ((ParameterizedType) e3).getActualTypeArguments()[a(e2.getTypeParameters(), typeVariable)];
        int i5 = d + 3;
        a = i5 % 128;
        int i6 = i5 % 2;
        return type3;
    }

    private static int a(Object[] objArr, Object obj) {
        int length;
        int i;
        int i2 = 2 % 2;
        int i3 = d + 121;
        int i4 = i3 % 128;
        a = i4;
        if (i3 % 2 != 0) {
            length = objArr.length;
            i = 1;
        } else {
            length = objArr.length;
            i = 0;
        }
        int i5 = i4 + 29;
        d = i5 % 128;
        int i6 = i5 % 2;
        while (i < length) {
            if (obj.equals(objArr[i])) {
                return i;
            }
            i++;
            int i7 = a + 123;
            d = i7 % 128;
            if (i7 % 2 == 0) {
                int i8 = 4 % 5;
            }
        }
        throw new NoSuchElementException();
    }

    private static Class<?> e(TypeVariable<?> typeVariable) {
        int i = 2 % 2;
        int i2 = d + 125;
        a = i2 % 128;
        int i3 = i2 % 2;
        Object genericDeclaration = typeVariable.getGenericDeclaration();
        Object obj = null;
        if (!(genericDeclaration instanceof Class)) {
            return null;
        }
        int i4 = a + 57;
        d = i4 % 128;
        Class<?> cls = (Class) genericDeclaration;
        if (i4 % 2 != 0) {
            return cls;
        }
        obj.hashCode();
        throw null;
    }

    static void d(Type type) {
        int i = 2 % 2;
        int i2 = d + 35;
        int i3 = i2 % 128;
        a = i3;
        int i4 = i2 % 2;
        boolean z = true;
        Object obj = null;
        if (type instanceof Class) {
            int i5 = i3 + 119;
            d = i5 % 128;
            Class cls = (Class) type;
            if (i5 % 2 == 0) {
                cls.isPrimitive();
                throw null;
            }
            if (!(!cls.isPrimitive())) {
                z = false;
            }
        }
        er.b(z);
        int i6 = a + 97;
        d = i6 % 128;
        if (i6 % 2 != 0) {
            return;
        }
        obj.hashCode();
        throw null;
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes.dex */
    public static final class b implements Serializable, ParameterizedType {
        private final Type c;
        private final Type[] d;
        private final Type e;

        public b(Type type, Type type2, Type... typeArr) {
            if (type2 instanceof Class) {
                Class cls = (Class) type2;
                boolean z = true;
                boolean z2 = Modifier.isStatic(cls.getModifiers()) || cls.getEnclosingClass() == null;
                if (type == null && !z2) {
                    z = false;
                }
                er.b(z);
            }
            this.e = type == null ? null : et.c(type);
            this.c = et.c(type2);
            Type[] typeArr2 = (Type[]) typeArr.clone();
            this.d = typeArr2;
            int length = typeArr2.length;
            for (int i = 0; i < length; i++) {
                er.a(this.d[i]);
                et.d(this.d[i]);
                Type[] typeArr3 = this.d;
                typeArr3[i] = et.c(typeArr3[i]);
            }
        }

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

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

        public final int hashCode() {
            return (Arrays.hashCode(this.d) ^ this.c.hashCode()) ^ et.e((Object) this.e);
        }

        public final String toString() {
            int length = this.d.length;
            if (length == 0) {
                return et.b(this.c);
            }
            StringBuilder sb = new StringBuilder((length + 1) * 30);
            sb.append(et.b(this.c));
            sb.append(UrlTreeKt.configurablePathSegmentPrefix);
            sb.append(et.b(this.d[0]));
            for (int i = 1; i < length; i++) {
                sb.append(", ");
                sb.append(et.b(this.d[i]));
            }
            sb.append(UrlTreeKt.configurablePathSegmentSuffix);
            return sb.toString();
        }

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

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

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

        public d(Type type) {
            this.a = et.c(type);
        }

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

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

        public final String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(et.b(this.a));
            sb.append(HttpUrl.PATH_SEGMENT_ENCODE_SET_URI);
            return sb.toString();
        }

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

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes.dex */
    public static final class a implements Serializable, WildcardType {
        private final Type c;
        private final Type e;

        public a(Type[] typeArr, Type[] typeArr2) {
            er.b(typeArr2.length <= 1);
            er.b(typeArr.length == 1);
            if (typeArr2.length == 1) {
                er.a(typeArr2[0]);
                et.d(typeArr2[0]);
                er.b(typeArr[0] == Object.class);
                this.e = et.c(typeArr2[0]);
                this.c = Object.class;
                return;
            }
            er.a(typeArr[0]);
            et.d(typeArr[0]);
            this.e = null;
            this.c = et.c(typeArr[0]);
        }

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

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

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

        public final String toString() {
            if (this.e != null) {
                StringBuilder sb = new StringBuilder("? super ");
                sb.append(et.b(this.e));
                return sb.toString();
            }
            if (this.c == Object.class) {
                return "?";
            }
            StringBuilder sb2 = new StringBuilder("? extends ");
            sb2.append(et.b(this.c));
            return sb2.toString();
        }

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

    static void a() {
        b = new char[]{40011, 40072, 40073, 40053};
    }

    static {
        d = 1;
        a();
        e = new Type[0];
        int i = a + 107;
        d = i % 128;
        if (i % 2 != 0) {
            return;
        }
        Object obj = null;
        obj.hashCode();
        throw null;
    }
}