package defpackage;

import java.lang.reflect.Field;
import java.nio.Buffer;
import java.nio.ByteOrder;
import java.security.AccessController;
import java.util.logging.Level;
import java.util.logging.Logger;
import libcore.io.Memory;
import sun.misc.Unsafe;

/* renamed from: ʽˋ, reason: contains not printable characters */
/* loaded from: classes3.dex */
public abstract class AbstractC0109 {

    /* renamed from: ˇʼʤˎ, reason: contains not printable characters */
    public static final long f1399;

    /* renamed from: ˏˋٴ, reason: contains not printable characters */
    public static final boolean f1400;

    /* renamed from: ˏᵙ, reason: contains not printable characters */
    public static final AbstractC4186 f1401;

    /* renamed from: ᵥᵯˎ, reason: contains not printable characters */
    public static final Unsafe f1402;

    /* renamed from: ᵴᵳ, reason: contains not printable characters */
    public static final Class f1403;

    /* renamed from: ᵻᵢﹳᵰ, reason: contains not printable characters */
    public static final boolean f1404;

    /* JADX WARN: Multi-variable type inference failed */
    /* JADX WARN: Type inference failed for: r16v0 */
    /* JADX WARN: Type inference failed for: r16v1 */
    /* JADX WARN: Type inference failed for: r16v2 */
    static {
        ?? r16;
        boolean z;
        AbstractC4186 abstractC4186;
        Unsafe unsafeM1198 = m1198();
        f1402 = unsafeM1198;
        int i = AbstractC5422.f20320;
        f1403 = Memory.class;
        Class<?> cls = Long.TYPE;
        boolean zM1206 = m1206(cls);
        Class<?> cls2 = Integer.TYPE;
        boolean zM12062 = m1206(cls2);
        AbstractC4186 c2987 = null;
        if (unsafeM1198 != null) {
            if (zM1206) {
                c2987 = new C3055(unsafeM1198);
            } else if (zM12062) {
                c2987 = new C2987(unsafeM1198);
            }
        }
        f1401 = c2987;
        if (c2987 != null) {
            try {
                Class<?> cls3 = c2987.f15659.getClass();
                cls3.getMethod("objectFieldOffset", Field.class);
                cls3.getMethod("getLong", Object.class, cls);
                m1204();
                r16 = 0;
            } catch (Throwable th) {
                r16 = 0;
                Logger.getLogger(AbstractC0109.class.getName()).logp(Level.WARNING, "com.google.protobuf.UnsafeUtil", "logMissingMethod", "platform method missing - proto runtime falling back to safer methods: ".concat(th.toString()));
            }
        } else {
            r16 = 0;
        }
        AbstractC4186 abstractC41862 = f1401;
        if (abstractC41862 == null) {
            z = r16;
        } else {
            try {
                Class<?> cls4 = abstractC41862.f15659.getClass();
                Class<?>[] clsArr = new Class[1];
                clsArr[r16] = Field.class;
                cls4.getMethod("objectFieldOffset", clsArr);
                Class<?>[] clsArr2 = new Class[1];
                clsArr2[r16] = Class.class;
                cls4.getMethod("arrayBaseOffset", clsArr2);
                Class<?>[] clsArr3 = new Class[1];
                clsArr3[r16] = Class.class;
                cls4.getMethod("arrayIndexScale", clsArr3);
                Class<?>[] clsArr4 = new Class[2];
                clsArr4[r16] = Object.class;
                clsArr4[1] = cls;
                cls4.getMethod("getInt", clsArr4);
                Class<?>[] clsArr5 = new Class[3];
                clsArr5[r16] = Object.class;
                clsArr5[1] = cls;
                clsArr5[2] = cls2;
                cls4.getMethod("putInt", clsArr5);
                Class<?>[] clsArr6 = new Class[2];
                clsArr6[r16] = Object.class;
                clsArr6[1] = cls;
                cls4.getMethod("getLong", clsArr6);
                Class<?>[] clsArr7 = new Class[3];
                clsArr7[r16] = Object.class;
                clsArr7[1] = cls;
                clsArr7[2] = cls;
                cls4.getMethod("putLong", clsArr7);
                Class<?>[] clsArr8 = new Class[2];
                clsArr8[r16] = Object.class;
                clsArr8[1] = cls;
                cls4.getMethod("getObject", clsArr8);
                Class<?>[] clsArr9 = new Class[3];
                clsArr9[r16] = Object.class;
                clsArr9[1] = cls;
                clsArr9[2] = Object.class;
                cls4.getMethod("putObject", clsArr9);
                z = true;
            } catch (Throwable th2) {
                Logger.getLogger(AbstractC0109.class.getName()).logp(Level.WARNING, "com.google.protobuf.UnsafeUtil", "logMissingMethod", "platform method missing - proto runtime falling back to safer methods: ".concat(th2.toString()));
            }
        }
        f1404 = z;
        f1399 = m1197(byte[].class);
        m1197(boolean[].class);
        m1203(boolean[].class);
        m1197(int[].class);
        m1203(int[].class);
        m1197(long[].class);
        m1203(long[].class);
        m1197(float[].class);
        m1203(float[].class);
        m1197(double[].class);
        m1203(double[].class);
        m1197(Object[].class);
        m1203(Object[].class);
        Field fieldM1204 = m1204();
        if (fieldM1204 != null && (abstractC4186 = f1401) != null) {
            abstractC4186.f15659.objectFieldOffset(fieldM1204);
        }
        f1400 = ByteOrder.nativeOrder() != ByteOrder.BIG_ENDIAN ? r16 : true;
    }

    /* renamed from: ˇʼʤˎ, reason: contains not printable characters */
    public static int m1196(long j, Object obj) {
        return f1401.f15659.getInt(obj, j);
    }

    /* renamed from: ˌʾˀ, reason: contains not printable characters */
    public static int m1197(Class cls) {
        if (f1404) {
            return f1401.f15659.arrayBaseOffset(cls);
        }
        return -1;
    }

    /* renamed from: ˌᵜᵹᵩ, reason: contains not printable characters */
    public static Unsafe m1198() {
        Unsafe unsafe;
        try {
            unsafe = (Unsafe) AccessController.doPrivileged(new C1984());
        } catch (Throwable unused) {
            unsafe = null;
        }
        if (unsafe == null) {
            return null;
        }
        try {
            unsafe.arrayBaseOffset(byte[].class);
            return unsafe;
        } catch (Exception unused2) {
            Logger.getLogger(AbstractC0109.class.getName()).logp(Level.WARNING, "com.google.protobuf.UnsafeUtil", "getUnsafe", "As part of the planned removal, sun.misc.Unsafe is available in the current environment but configured to throw on use. Protobuf will continue without using it, but with slightly reduced performance. --sun-misc-unsafe-memory-access=allow is likely available to opt back in if desired. A later Protobuf version release will stop using sun.misc.Unsafe entirely.");
            return null;
        }
    }

    /* renamed from: ˎˏʜʾ, reason: contains not printable characters */
    public static long m1199(long j, Object obj) {
        return f1401.f15659.getLong(obj, j);
    }

    /* renamed from: ˏˋٴ, reason: contains not printable characters */
    public static void m1200(long j, Object obj, int i) {
        f1401.f15659.putInt(obj, j, i);
    }

    /* renamed from: ˏᵙ, reason: contains not printable characters */
    public static void m1201(Object obj, long j, byte b) {
        Unsafe unsafe = f1401.f15659;
        long j2 = (-4) & j;
        int i = (((int) j) & 3) << 3;
        unsafe.putInt(obj, j2, ((255 & b) << i) | (unsafe.getInt(obj, j2) & (~(255 << i))));
    }

    /* renamed from: ᵝᵵᵺ, reason: contains not printable characters */
    public static Object m1202(long j, Object obj) {
        return f1401.f15659.getObject(obj, j);
    }

    /* renamed from: ᵡʠ, reason: contains not printable characters */
    public static void m1203(Class cls) {
        if (f1404) {
            f1401.f15659.arrayIndexScale(cls);
        }
    }

    /* renamed from: ᵥᵯˎ, reason: contains not printable characters */
    public static Field m1204() {
        Field declaredField;
        Field declaredField2;
        int i = AbstractC5422.f20320;
        try {
            declaredField = Buffer.class.getDeclaredField("effectiveDirectAddress");
        } catch (Throwable unused) {
            declaredField = null;
        }
        if (declaredField != null) {
            return declaredField;
        }
        try {
            declaredField2 = Buffer.class.getDeclaredField("address");
        } catch (Throwable unused2) {
            declaredField2 = null;
        }
        if (declaredField2 == null || declaredField2.getType() != Long.TYPE) {
            return null;
        }
        return declaredField2;
    }

    /* renamed from: ᵪʩ, reason: contains not printable characters */
    public static /* synthetic */ boolean m1205(long j, Object obj) {
        return ((byte) ((f1401.f15659.getInt(obj, (-4) & j) >>> ((int) (((~j) & 3) << 3))) & 255)) != 0;
    }

    /* JADX WARN: Multi-variable type inference failed */
    /* renamed from: ᵯٴᵦ, reason: contains not printable characters */
    public static boolean m1206(Class cls) {
        int i = AbstractC5422.f20320;
        try {
            Class cls2 = f1403;
            Class cls3 = Boolean.TYPE;
            cls2.getMethod("peekLong", cls, cls3);
            cls2.getMethod("pokeLong", cls, Long.TYPE, cls3);
            Class cls4 = Integer.TYPE;
            cls2.getMethod("pokeInt", cls, cls4, cls3);
            cls2.getMethod("peekInt", cls, cls3);
            cls2.getMethod("pokeByte", cls, Byte.TYPE);
            cls2.getMethod("peekByte", cls);
            cls2.getMethod("pokeByteArray", cls, byte[].class, cls4, cls4);
            cls2.getMethod("peekByteArray", cls, byte[].class, cls4, cls4);
            return true;
        } catch (Throwable unused) {
            return false;
        }
    }

    /* renamed from: ᵳٴᵶ, reason: contains not printable characters */
    public static /* synthetic */ boolean m1207(long j, Object obj) {
        return ((byte) ((f1401.f15659.getInt(obj, (-4) & j) >>> ((int) ((j & 3) << 3))) & 255)) != 0;
    }

    /* renamed from: ᵴᵳ, reason: contains not printable characters */
    public static void m1208(Object obj, long j, byte b) {
        Unsafe unsafe = f1401.f15659;
        long j2 = (-4) & j;
        int i = unsafe.getInt(obj, j2);
        int i2 = ((~((int) j)) & 3) << 3;
        unsafe.putInt(obj, j2, ((255 & b) << i2) | (i & (~(255 << i2))));
    }

    /* renamed from: ᵶᵷᵕ, reason: contains not printable characters */
    public static void m1209(Object obj, long j, Object obj2) {
        f1401.f15659.putObject(obj, j, obj2);
    }

    /* renamed from: ᵸˑ, reason: contains not printable characters */
    public static void m1210(byte[] bArr, long j, byte b) {
        f1401.mo7300(bArr, f1399 + j, b);
    }

    /* renamed from: ᵹᵝᵶ, reason: contains not printable characters */
    public static void m1211(Object obj, long j, long j2) {
        f1401.f15659.putLong(obj, j, j2);
    }

    /* renamed from: ᵻᵢﹳᵰ, reason: contains not printable characters */
    public static Object m1212(Class cls) {
        try {
            return f1402.allocateInstance(cls);
        } catch (InstantiationException e) {
            C2707.m6713(e);
            return null;
        }
    }
}