package defpackage;

import android.net.Uri;
import android.os.Build;
import android.widget.EdgeEffect;
import ar.tvplayer.core.domain.F;
import ar.tvplayer.core.domain.ᵠˏˏ;
import ar.tvplayer.tv.R;
import j$.util.Objects;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Array;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.GenericDeclaration;
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.Calendar;
import java.util.LinkedHashSet;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import kotlinx.coroutines.DispatchException;

/* JADX INFO: renamed from: ᵥʾˉ, reason: contains not printable characters */
/* JADX INFO: loaded from: classes3.dex */
public abstract class AbstractC3481 {

    /* JADX INFO: renamed from: ˈᵲᵢ, reason: contains not printable characters */
    public static boolean f13402 = true;

    /* JADX INFO: renamed from: ᵯᵷʽ, reason: contains not printable characters */
    public static boolean f13406 = true;

    /* JADX INFO: renamed from: ᵶˇᵱ, reason: contains not printable characters */
    public static volatile boolean f13407 = true;

    /* JADX INFO: renamed from: ˌᴵ, reason: contains not printable characters */
    public final /* synthetic */ int f13408;

    /* JADX INFO: renamed from: ᵜᵪʾ, reason: contains not printable characters */
    public static final char[] f13404 = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};

    /* JADX INFO: renamed from: ᵔᵖᵹᵫ, reason: contains not printable characters */
    public static final char[] f13403 = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

    /* JADX INFO: renamed from: ᵨᵼⁱ, reason: contains not printable characters */
    public static final Type[] f13405 = new Type[0];

    public /* synthetic */ AbstractC3481(int i) {
        this.f13408 = i;
    }

    /* JADX INFO: renamed from: ʿٴˇ, reason: contains not printable characters */
    public static boolean m7917(Annotation[] annotationArr, Class cls) {
        for (Annotation annotation : annotationArr) {
            if (cls.isInstance(annotation)) {
                return true;
            }
        }
        return false;
    }

    /* JADX INFO: renamed from: ˀᵗ, reason: contains not printable characters */
    public static int m7918(int i) {
        return (i >>> 1) ^ (-(i & 1));
    }

    /* JADX INFO: renamed from: ˀᵭ, reason: contains not printable characters */
    public static IllegalArgumentException m7919(Method method, int i, String str, Object... objArr) {
        return m7925(method, null, str + " (" + AbstractC1286.f5371.ᵟᵹᵙ(i, method) + ")", objArr);
    }

    /* JADX INFO: renamed from: ˁʢᵛ, reason: contains not printable characters */
    public static byte m7920(byte b, int i) {
        return (byte) (b & (~(1 << i)));
    }

    /* JADX INFO: renamed from: ˁˌᵩ, reason: contains not printable characters */
    public static float m7921(EdgeEffect edgeEffect, float f, float f2) {
        if (Build.VERSION.SDK_INT >= 31) {
            return AbstractC0319.m1569(edgeEffect, f, f2);
        }
        edgeEffect.onPull(f, f2);
        return f;
    }

    /* JADX INFO: renamed from: ˈᵲᵢ, reason: contains not printable characters */
    public static final int m7922(int i) {
        if (i == 0) {
            return 1;
        }
        if (i == 1) {
            return 2;
        }
        ᵕᵩʽᵲ.ᵮᵣᵗˈ(AbstractC0793.m2876(i, "Could not convert ", " to OutOfQuotaPolicy"));
        return 0;
    }

    /* JADX INFO: renamed from: ˈⁱᵡ, reason: contains not printable characters */
    public static void m7923(Throwable th) {
        if (th instanceof VirtualMachineError) {
            throw ((VirtualMachineError) th);
        }
        if (th instanceof ThreadDeath) {
            throw ((ThreadDeath) th);
        }
        if (th instanceof LinkageError) {
            throw ((LinkageError) th);
        }
    }

    /* JADX INFO: renamed from: ˉᵲ, reason: contains not printable characters */
    public static Type m7924(Type type, Class cls, Class cls2) {
        if (cls2 == cls) {
            return type;
        }
        if (cls2.isInterface()) {
            Class<?>[] interfaces = cls.getInterfaces();
            int length = interfaces.length;
            for (int i = 0; i < length; i++) {
                Class<?> cls3 = interfaces[i];
                if (cls3 == cls2) {
                    return cls.getGenericInterfaces()[i];
                }
                if (cls2.isAssignableFrom(cls3)) {
                    return m7924(cls.getGenericInterfaces()[i], interfaces[i], cls2);
                }
            }
        }
        if (!cls.isInterface()) {
            while (cls != Object.class) {
                Class<?> superclass = cls.getSuperclass();
                if (superclass == cls2) {
                    return cls.getGenericSuperclass();
                }
                if (cls2.isAssignableFrom(superclass)) {
                    return m7924(cls.getGenericSuperclass(), superclass, cls2);
                }
                cls = superclass;
            }
        }
        return cls2;
    }

    /* JADX INFO: renamed from: ˉᵵᵜ, reason: contains not printable characters */
    public static IllegalArgumentException m7925(Method method, Exception exc, String str, Object... objArr) {
        return new IllegalArgumentException(String.format(str, objArr) + "\n    for method " + method.getDeclaringClass().getSimpleName() + "." + method.getName(), exc);
    }

    /* JADX INFO: renamed from: ˊˌˊ, reason: contains not printable characters */
    public static String m7926(Type type) {
        return type instanceof Class ? ((Class) type).getName() : type.toString();
    }

    /* JADX INFO: renamed from: ˊᵙᵾᵲ, reason: contains not printable characters */
    public static float m7927(EdgeEffect edgeEffect) {
        if (Build.VERSION.SDK_INT >= 31) {
            return AbstractC0319.m1568(edgeEffect);
        }
        return 0.0f;
    }

    /* JADX WARN: Removed duplicated region for block: B:21:0x003e  */
    /* JADX INFO: renamed from: ˊᵡᵗʨ, reason: contains not printable characters */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static Type m7928(Type type, Class cls, Type type2) {
        Type type3;
        Type type4 = type2;
        while (true) {
            int i = 0;
            if (!(type4 instanceof TypeVariable)) {
                if (type4 instanceof Class) {
                    Class cls2 = (Class) type4;
                    if (cls2.isArray()) {
                        Class<?> componentType = cls2.getComponentType();
                        Type typeM7928 = m7928(type, cls, componentType);
                        return componentType == typeM7928 ? cls2 : new C0616(typeM7928);
                    }
                }
                if (type4 instanceof GenericArrayType) {
                    GenericArrayType genericArrayType = (GenericArrayType) type4;
                    Type genericComponentType = genericArrayType.getGenericComponentType();
                    Type typeM79282 = m7928(type, cls, genericComponentType);
                    return genericComponentType == typeM79282 ? genericArrayType : new C0616(typeM79282);
                }
                if (type4 instanceof ParameterizedType) {
                    ParameterizedType parameterizedType = (ParameterizedType) type4;
                    Type ownerType = parameterizedType.getOwnerType();
                    Type typeM79283 = m7928(type, cls, ownerType);
                    boolean z = typeM79283 != ownerType;
                    Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                    int length = actualTypeArguments.length;
                    while (i < length) {
                        Type typeM79284 = m7928(type, cls, actualTypeArguments[i]);
                        if (typeM79284 != actualTypeArguments[i]) {
                            if (!z) {
                                actualTypeArguments = (Type[]) actualTypeArguments.clone();
                                z = true;
                            }
                            actualTypeArguments[i] = typeM79284;
                        }
                        i++;
                    }
                    return z ? new C4384(typeM79283, parameterizedType.getRawType(), actualTypeArguments) : parameterizedType;
                }
                boolean z2 = type4 instanceof WildcardType;
                Type type5 = type4;
                if (z2) {
                    WildcardType wildcardType = (WildcardType) type4;
                    Type[] lowerBounds = wildcardType.getLowerBounds();
                    Type[] upperBounds = wildcardType.getUpperBounds();
                    if (lowerBounds.length == 1) {
                        Type typeM79285 = m7928(type, cls, lowerBounds[0]);
                        type5 = wildcardType;
                        if (typeM79285 != lowerBounds[0]) {
                            return new C3038(new Type[]{Object.class}, new Type[]{typeM79285});
                        }
                    } else {
                        type5 = wildcardType;
                        if (upperBounds.length == 1) {
                            Type typeM79286 = m7928(type, cls, upperBounds[0]);
                            type5 = wildcardType;
                            if (typeM79286 != upperBounds[0]) {
                                return new C3038(new Type[]{typeM79286}, f13405);
                            }
                        }
                    }
                }
                return type5;
            }
            TypeVariable typeVariable = (TypeVariable) type4;
            GenericDeclaration genericDeclaration = typeVariable.getGenericDeclaration();
            Class cls3 = genericDeclaration instanceof Class ? (Class) genericDeclaration : null;
            if (cls3 == null) {
                type3 = typeVariable;
            } else {
                Type typeM7924 = m7924(type, cls, cls3);
                if (typeM7924 instanceof ParameterizedType) {
                    TypeVariable[] typeParameters = cls3.getTypeParameters();
                    while (i < typeParameters.length) {
                        if (typeVariable.equals(typeParameters[i])) {
                            type3 = ((ParameterizedType) typeM7924).getActualTypeArguments()[i];
                        } else {
                            i++;
                        }
                    }
                    C4468.m9518();
                    return null;
                }
            }
            if (type3 == typeVariable) {
                return type3;
            }
            type4 = type3;
        }
    }

    /* JADX INFO: renamed from: ˊᵨᵧ, reason: contains not printable characters */
    public static Class m7929(Type type) {
        Objects.requireNonNull(type, "type == null");
        if (type instanceof Class) {
            return (Class) type;
        }
        if (type instanceof ParameterizedType) {
            Type rawType = ((ParameterizedType) type).getRawType();
            if (rawType instanceof Class) {
                return (Class) rawType;
            }
            ᵷᵝˎ.ᵷᵺʾᵖ();
            return null;
        }
        if (type instanceof GenericArrayType) {
            return Array.newInstance((Class<?>) m7929(((GenericArrayType) type).getGenericComponentType()), 0).getClass();
        }
        if (type instanceof TypeVariable) {
            return Object.class;
        }
        if (type instanceof WildcardType) {
            return m7929(((WildcardType) type).getUpperBounds()[0]);
        }
        StringBuilder sb = new StringBuilder("Expected a Class, ParameterizedType, or GenericArrayType, but <");
        sb.append(type);
        C4468.m9513(sb, "> is of type ", type.getClass().getName());
        return null;
    }

    /* JADX INFO: renamed from: ˊᵫᵗ, reason: contains not printable characters */
    public static byte m7930(long j) {
        ᵻᵪ.ˊᵫᵗ(j, "out of range: %s", (j >> 8) == 0);
        return (byte) j;
    }

    /* JADX INFO: renamed from: ˊᵾʽʼ, reason: contains not printable characters */
    public static IllegalArgumentException m7931(Method method, Exception exc, int i, String str, Object... objArr) {
        return m7925(method, exc, str + " (" + AbstractC1286.f5371.ᵟᵹᵙ(i, method) + ")", objArr);
    }

    /* JADX INFO: renamed from: ˋˈ, reason: contains not printable characters */
    public static final void m7932(InterfaceC3822 interfaceC3822) {
        InterfaceC4645 interfaceC4645 = (InterfaceC4645) interfaceC3822.mo2664(C3664.f13909);
        if (interfaceC4645 != null && !interfaceC4645.mo6080()) {
            throw interfaceC4645.mo6083();
        }
    }

    /* JADX INFO: renamed from: ˌᴵ, reason: contains not printable characters */
    public static Type m7933(Type type, Class cls) {
        if (Map.class.isAssignableFrom(cls)) {
            return m7928(type, cls, m7924(type, cls, Map.class));
        }
        ᵷᵝˎ.ᵷᵺʾᵖ();
        return null;
    }

    /* JADX INFO: renamed from: ˌᵨʠᵫ, reason: contains not printable characters */
    public static final EnumC4913 m7934(int i) {
        if (i == 0) {
            return EnumC4913.f18695;
        }
        if (i == 1) {
            return EnumC4913.f18697;
        }
        if (i == 2) {
            return EnumC4913.f18696;
        }
        if (i == 3) {
            return EnumC4913.f18698;
        }
        if (i == 4) {
            return EnumC4913.f18699;
        }
        if (i == 5) {
            return EnumC4913.f18700;
        }
        ᵕᵩʽᵲ.ᵮᵣᵗˈ(AbstractC0793.m2876(i, "Could not convert ", " to State"));
        return null;
    }

    /* JADX INFO: renamed from: ˏːˆ, reason: contains not printable characters */
    public static Type m7935(int i, ParameterizedType parameterizedType) {
        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
        if (i >= 0 && i < actualTypeArguments.length) {
            Type type = actualTypeArguments[i];
            return type instanceof WildcardType ? ((WildcardType) type).getUpperBounds()[0] : type;
        }
        StringBuilder sbM8237 = AbstractC3653.m8237(i, "Index ", " not in range [0,");
        sbM8237.append(actualTypeArguments.length);
        sbM8237.append(") for ");
        sbM8237.append(parameterizedType);
        throw new IllegalArgumentException(sbM8237.toString());
    }

    /* JADX INFO: renamed from: ːˏᵟᵯ, reason: contains not printable characters */
    public static C1204 m7936() {
        return new C1204(null);
    }

    /* JADX INFO: renamed from: ˑʢ, reason: contains not printable characters */
    public static final int m7937(EnumC4913 enumC4913) {
        int iOrdinal = enumC4913.ordinal();
        if (iOrdinal == 0) {
            return 0;
        }
        int i = 1;
        if (iOrdinal != 1) {
            i = 2;
            if (iOrdinal != 2) {
                i = 3;
                if (iOrdinal != 3) {
                    i = 4;
                    if (iOrdinal != 4) {
                        if (iOrdinal == 5) {
                            return 5;
                        }
                        C1685.m4561();
                        return 0;
                    }
                }
            }
        }
        return i;
    }

    /* JADX INFO: renamed from: ˑˊᵲ, reason: contains not printable characters */
    public static final boolean m7938(InterfaceC3822 interfaceC3822) {
        InterfaceC4645 interfaceC4645 = (InterfaceC4645) interfaceC3822.mo2664(C3664.f13909);
        if (interfaceC4645 != null) {
            return interfaceC4645.mo6080();
        }
        return true;
    }

    /* JADX INFO: renamed from: ᵔᵖᵹᵫ, reason: contains not printable characters */
    public static boolean m7939(Type type) {
        if (type instanceof Class) {
            return false;
        }
        if (!(type instanceof ParameterizedType)) {
            if (type instanceof GenericArrayType) {
                return m7939(((GenericArrayType) type).getGenericComponentType());
            }
            if ((type instanceof TypeVariable) || (type instanceof WildcardType)) {
                return true;
            }
            C4468.m9510("Expected a Class, ParameterizedType, or GenericArrayType, but <", type, "> is of type ", type == null ? "null" : type.getClass().getName());
            return false;
        }
        for (Type type2 : ((ParameterizedType) type).getActualTypeArguments()) {
            if (m7939(type2)) {
                return true;
            }
        }
        return false;
    }

    /* JADX INFO: renamed from: ᵛˑﹳ, reason: contains not printable characters */
    public static byte m7940(byte b, int i) {
        return (byte) (b | (1 << i));
    }

    /* JADX INFO: renamed from: ᵜᵪʾ, reason: contains not printable characters */
    public static final void m7941(InterfaceC3822 interfaceC3822, Throwable th) {
        if (th instanceof DispatchException) {
            th = ((DispatchException) th).f1143;
        }
        try {
            C3141 c3141 = (C3141) interfaceC3822.mo2664(ʻﾞ.ᵜᵪʾ);
            if (c3141 != null) {
                c3141.m7247(th);
            } else {
                ᵷᵸˁ.ˉᵲ(interfaceC3822, th);
            }
        } catch (Throwable th2) {
            if (th != th2) {
                RuntimeException runtimeException = new RuntimeException("Exception while trying to handle coroutine exception", th2);
                ᵷˆᵣ.ʽˈˋ(runtimeException, th);
                th = runtimeException;
            }
            ᵷᵸˁ.ˉᵲ(interfaceC3822, th);
        }
    }

    /* JADX INFO: renamed from: ᵞᵛᵘ, reason: contains not printable characters */
    public static final C3512 m7942(byte[] bArr) throws IOException {
        if (Build.VERSION.SDK_INT < 28 || bArr.length == 0) {
            return new C3512(null);
        }
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bArr);
        try {
            ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
            try {
                int i = objectInputStream.readInt();
                int[] iArr = new int[i];
                for (int i2 = 0; i2 < i; i2++) {
                    iArr[i2] = objectInputStream.readInt();
                }
                int i3 = objectInputStream.readInt();
                int[] iArr2 = new int[i3];
                for (int i4 = 0; i4 < i3; i4++) {
                    iArr2[i4] = objectInputStream.readInt();
                }
                C3512 c3512M2176 = AbstractC0562.m2176(iArr2, iArr);
                objectInputStream.close();
                byteArrayInputStream.close();
                return c3512M2176;
            } finally {
            }
        } finally {
        }
    }

    /* JADX INFO: renamed from: ᵟᵹᵙ, reason: contains not printable characters */
    public static boolean m7943(Map map, Object obj) {
        if (map == obj) {
            return true;
        }
        if (obj instanceof Map) {
            return map.entrySet().equals(((Map) obj).entrySet());
        }
        return false;
    }

    /* JADX INFO: renamed from: ᵠˏˏ, reason: contains not printable characters */
    public static boolean m7944(byte b, int i) {
        return ((1 << i) & ((long) b)) != 0;
    }

    /* JADX INFO: renamed from: ᵨˈʼﹶ, reason: contains not printable characters */
    public static final void m7945(String str) {
        throw new IllegalArgumentException(str);
    }

    /* JADX INFO: renamed from: ᵨᵣ, reason: contains not printable characters */
    public static String m7946(byte[] bArr) {
        int length = bArr.length;
        StringBuilder sb = new StringBuilder(length + length);
        for (int i = 0; i < length; i++) {
            int i2 = (bArr[i] & 240) >>> 4;
            char[] cArr = f13404;
            sb.append(cArr[i2]);
            sb.append(cArr[bArr[i] & 15]);
        }
        return sb.toString();
    }

    /* JADX INFO: renamed from: ᵨᵼⁱ, reason: contains not printable characters */
    public static final void m7947(AbstractC0651 abstractC0651) {
        int iByteValue;
        byte[] bArr = ᵷᵸˁ.ᵱᵽʡᵚ;
        if (bArr == null || (((byte) (bArr[348] - ˏʥːʟ.ᵻˈᵦʼ()[348])) == 81 && F.ᵲᵶᵳˈ.uGm4U(348) == bArr[350] + 31)) {
            ᵠˏˏ.ᵝᵶ();
        } else {
            ˁᵘʤᵢ.ᵷᵺʾᵖ = false;
            int i = ᵠˏˏ.ᵨᵣ;
            while (i != ((double) ᵠˏˏ.ᵨᵣ) + 0.1d) {
                i++;
            }
            Byte bM8432 = AbstractC3761.m8432(28188 * i, bArr);
            if (bM8432 != null) {
                iByteValue = bM8432.byteValue();
            } else {
                iByteValue = ᵠˏˏ.ᵨᵣ;
                ᵠˏˏ.ᵨᵣ = iByteValue + 1;
            }
            ᵠˏˏ.ᵨᵣ = iByteValue;
            boolean z = ˁᵘʤᵢ.ᵲᵶᵳˈ;
        }
        boolean z2 = ᵕᵛ.ᵲᵶᵳˈ;
        AbstractComponentCallbacksC3393 abstractComponentCallbacksC3393M2368 = abstractC0651.m2368(ᵸˎʿ.class.getName());
        DialogInterfaceOnCancelListenerC0244 dialogInterfaceOnCancelListenerC0244 = abstractComponentCallbacksC3393M2368 instanceof DialogInterfaceOnCancelListenerC0244 ? (DialogInterfaceOnCancelListenerC0244) abstractComponentCallbacksC3393M2368 : null;
        if (dialogInterfaceOnCancelListenerC0244 == null) {
            return;
        }
        dialogInterfaceOnCancelListenerC0244.m1440(false);
        try {
            abstractC0651.m2350(true);
            abstractC0651.m2340();
        } catch (Exception unused) {
        }
    }

    /* JADX INFO: renamed from: ᵪᵹᵥᵻ, reason: contains not printable characters */
    public static boolean m7948(Type type, Type type2) {
        if (type == type2) {
            return true;
        }
        if (type instanceof Class) {
            return type.equals(type2);
        }
        if (type instanceof ParameterizedType) {
            if (!(type2 instanceof ParameterizedType)) {
                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 (type2 instanceof GenericArrayType) {
                return m7948(((GenericArrayType) type).getGenericComponentType(), ((GenericArrayType) type2).getGenericComponentType());
            }
            return false;
        }
        if (type instanceof WildcardType) {
            if (!(type2 instanceof WildcardType)) {
                return false;
            }
            WildcardType wildcardType = (WildcardType) type;
            WildcardType wildcardType2 = (WildcardType) type2;
            return Arrays.equals(wildcardType.getUpperBounds(), wildcardType2.getUpperBounds()) && Arrays.equals(wildcardType.getLowerBounds(), wildcardType2.getLowerBounds());
        }
        if (!(type instanceof TypeVariable) || !(type2 instanceof TypeVariable)) {
            return false;
        }
        TypeVariable typeVariable = (TypeVariable) type;
        TypeVariable typeVariable2 = (TypeVariable) type2;
        return typeVariable.getGenericDeclaration() == typeVariable2.getGenericDeclaration() && typeVariable.getName().equals(typeVariable2.getName());
    }

    /* JADX INFO: renamed from: ᵯᵷʽ, reason: contains not printable characters */
    public static final int m7949(int i) {
        if (i == 0) {
            return 1;
        }
        if (i == 1) {
            return 2;
        }
        ᵕᵩʽᵲ.ᵮᵣᵗˈ(AbstractC0793.m2876(i, "Could not convert ", " to BackoffPolicy"));
        return 0;
    }

    /* JADX INFO: renamed from: ᵱʡˏ, reason: contains not printable characters */
    public static Calendar m7950(Calendar calendar, Locale locale) {
        if (calendar == null) {
            return Calendar.getInstance(locale);
        }
        long timeInMillis = calendar.getTimeInMillis();
        Calendar calendar2 = Calendar.getInstance(locale);
        calendar2.setTimeInMillis(timeInMillis);
        return calendar2;
    }

    /* JADX INFO: renamed from: ᵱᵽʡᵚ, reason: contains not printable characters */
    public static String[] m7951(int i, int i2) {
        String[] strArr = new String[(i2 - i) + 1];
        for (int i3 = i; i3 <= i2; i3++) {
            strArr[i3 - i] = String.format("%02d", Integer.valueOf(i3));
        }
        return strArr;
    }

    /* JADX INFO: renamed from: ᵵᵬᵽ, reason: contains not printable characters */
    public static void m7952(AbstractC0651 abstractC0651, String str, int i) {
        int iByteValue;
        if ((i & 1) != 0) {
            str = ᵵᵼʼ.ᵲᵶᵳˈ().getString(R.string._2js_res_0x7f1301d6);
        }
        ˋᵹᵼˇ r1 = new ˋᵹᵼˇ(str, (i & 2) == 0);
        byte[] bArr = ᵷᵸˁ.ᵱᵽʡᵚ;
        if (bArr == null || (((byte) (bArr[412] - ˏʥːʟ.ᵻˈᵦʼ()[412])) == 118 && F.ᵲᵶᵳˈ.sM1eT(412) == bArr[419] + 73)) {
            ᵠˏˏ.ᵝᵶ();
        } else {
            ˁᵘʤᵢ.ᵷᵺʾᵖ = false;
            int i2 = ᵠˏˏ.ᵨᵣ;
            while (i2 != ((double) ᵠˏˏ.ᵨᵣ) + 0.1d) {
                i2++;
            }
            Byte bM8432 = AbstractC3761.m8432(48616 * i2, bArr);
            if (bM8432 != null) {
                iByteValue = bM8432.byteValue();
            } else {
                iByteValue = ᵠˏˏ.ᵨᵣ;
                ᵠˏˏ.ᵨᵣ = iByteValue + 1;
            }
            ᵠˏˏ.ᵨᵣ = iByteValue;
            boolean z = ˁᵘʤᵢ.ᵲᵶᵳˈ;
        }
        ᵕᵛ.ˆᵱʣ(abstractC0651, ᵸˎʿ.class, r1);
    }

    /* JADX INFO: renamed from: ᵵᵽ, reason: contains not printable characters */
    public static void m7953(Type type) {
        if ((type instanceof Class) && ((Class) type).isPrimitive()) {
            ᵷᵝˎ.ᵷᵺʾᵖ();
        }
    }

    /* JADX INFO: renamed from: ᵶˇᵱ, reason: contains not printable characters */
    public static final int m7954(int i) {
        if (i == 0) {
            return 1;
        }
        if (i == 1) {
            return 2;
        }
        if (i == 2) {
            return 3;
        }
        if (i == 3) {
            return 4;
        }
        if (i == 4) {
            return 5;
        }
        if (Build.VERSION.SDK_INT >= 30 && i == 5) {
            return 6;
        }
        ᵕᵩʽᵲ.ᵮᵣᵗˈ(AbstractC0793.m2876(i, "Could not convert ", " to NetworkType"));
        return 0;
    }

    /* JADX INFO: renamed from: ᵶᵥᵝ, reason: contains not printable characters */
    public static final long m7955() {
        return Thread.currentThread().getId();
    }

    /* JADX INFO: renamed from: ᵷᵺʾᵖ, reason: contains not printable characters */
    public static final LinkedHashSet m7956(byte[] bArr) throws IOException {
        ObjectInputStream objectInputStream;
        LinkedHashSet linkedHashSet = new LinkedHashSet();
        if (bArr.length == 0) {
            return linkedHashSet;
        }
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bArr);
        try {
            try {
                objectInputStream = new ObjectInputStream(byteArrayInputStream);
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                int i = objectInputStream.readInt();
                for (int i2 = 0; i2 < i; i2++) {
                    linkedHashSet.add(new C3646(Uri.parse(objectInputStream.readUTF()), objectInputStream.readBoolean()));
                }
                objectInputStream.close();
                byteArrayInputStream.close();
                return linkedHashSet;
            } finally {
            }
        } finally {
        }
    }

    /* JADX INFO: renamed from: ᵸˆˁ, reason: contains not printable characters */
    public static final InterfaceC0083 m7957(InterfaceC4645 interfaceC4645, boolean z, AbstractC1389 abstractC1389) {
        return interfaceC4645 instanceof C2374 ? ((C2374) interfaceC4645).m6060(z, abstractC1389) : interfaceC4645.mo6063(abstractC1389.mo3967(), z, new ˀᵭ(1, abstractC1389, AbstractC1389.class, "invoke", "invoke(Ljava/lang/Throwable;)V", 0, 0, 14));
    }

    /* JADX INFO: renamed from: ᵻˈᵦʼ, reason: contains not printable characters */
    public static int m7958(int i) {
        if (i < 3) {
            ˑᵕʾ.ːˏᵟᵯ(i, "expectedSize");
            return i + 1;
        }
        if (i < 1073741824) {
            return (int) Math.ceil(((double) i) / 0.75d);
        }
        return Integer.MAX_VALUE;
    }

    public String toString() {
        switch (this.f13408) {
            case C5224.BYTES_FIELD_NUMBER /* 8 */:
                return mo7601().toString();
            default:
                return super.toString();
        }
    }

    /* JADX INFO: renamed from: ʽᵡᵢᵾ, reason: contains not printable characters */
    public abstract void m7959();

    /* JADX INFO: renamed from: ᵝᵶ */
    public abstract Object mo7601();

    /* JADX INFO: renamed from: ᵮᵣᵗˈ */
    public abstract int mo6181(C1523 c1523);

    /* JADX INFO: renamed from: ᵻʽᵯ */
    public abstract void mo6182(C1523 c1523, Set set);
}