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 AbstractC4335 {

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

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

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

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

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

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

    /* 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 unsafeM9314 = m9314();
        f16243 = unsafeM9314;
        int i = AbstractC4340.f16260;
        f16244 = Memory.class;
        Class<?> cls = Long.TYPE;
        boolean zM9308 = m9308(cls);
        Class<?> cls2 = Integer.TYPE;
        boolean zM93082 = m9308(cls2);
        AbstractC4186 c0201 = null;
        if (unsafeM9314 != null) {
            if (zM9308) {
                c0201 = new C2607(unsafeM9314);
            } else if (zM93082) {
                c0201 = new C0201(unsafeM9314);
            }
        }
        f16242 = c0201;
        if (c0201 != null) {
            try {
                Class<?> cls3 = c0201.f15659.getClass();
                cls3.getMethod("objectFieldOffset", Field.class);
                cls3.getMethod("getLong", Object.class, cls);
                m9307();
                r16 = 0;
            } catch (Throwable th) {
                r16 = 0;
                Logger.getLogger(AbstractC4335.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 = f16242;
        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(AbstractC4335.class.getName()).logp(Level.WARNING, "com.google.protobuf.UnsafeUtil", "logMissingMethod", "platform method missing - proto runtime falling back to safer methods: ".concat(th2.toString()));
            }
        }
        f16245 = z;
        f16240 = m9310(byte[].class);
        m9310(boolean[].class);
        m9301(boolean[].class);
        m9310(int[].class);
        m9301(int[].class);
        m9310(long[].class);
        m9301(long[].class);
        m9310(float[].class);
        m9301(float[].class);
        m9310(double[].class);
        m9301(double[].class);
        m9310(Object[].class);
        m9301(Object[].class);
        Field fieldM9307 = m9307();
        if (fieldM9307 != null && (abstractC4186 = f16242) != null) {
            abstractC4186.f15659.objectFieldOffset(fieldM9307);
        }
        f16241 = ByteOrder.nativeOrder() != ByteOrder.BIG_ENDIAN ? r16 : true;
    }

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

    /* renamed from: ˌʾˀ, reason: contains not printable characters */
    public static void m9301(Class cls) {
        if (f16245) {
            f16242.f15659.arrayIndexScale(cls);
        }
    }

    /* renamed from: ˌᵜᵹᵩ, reason: contains not printable characters */
    public static /* bridge */ /* synthetic */ boolean m9302(long j, Object obj) {
        return ((byte) ((f16242.f15659.getInt(obj, (-4) & j) >>> ((int) (((~j) & 3) << 3))) & 255)) != 0;
    }

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

    /* renamed from: ˏˋٴ, reason: contains not printable characters */
    public static Object m9304(Class cls) {
        try {
            return f16243.allocateInstance(cls);
        } catch (InstantiationException e) {
            C2707.m6713(e);
            return null;
        }
    }

    /* renamed from: ˏᵙ, reason: contains not printable characters */
    public static void m9305(Object obj, long j, byte b) {
        Unsafe unsafe = f16242.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 void m9306(long j, Object obj, int i) {
        f16242.f15659.putInt(obj, j, i);
    }

    /* renamed from: ᵥᵯˎ, reason: contains not printable characters */
    public static Field m9307() {
        Field declaredField;
        Field declaredField2;
        int i = AbstractC4340.f16260;
        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;
    }

    /* JADX WARN: Multi-variable type inference failed */
    /* renamed from: ᵪʩ, reason: contains not printable characters */
    public static boolean m9308(Class cls) {
        int i = AbstractC4340.f16260;
        try {
            Class cls2 = f16244;
            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 /* bridge */ /* synthetic */ boolean m9309(long j, Object obj) {
        return ((byte) ((f16242.f15659.getInt(obj, (-4) & j) >>> ((int) ((j & 3) << 3))) & 255)) != 0;
    }

    /* renamed from: ᵳٴᵶ, reason: contains not printable characters */
    public static int m9310(Class cls) {
        if (f16245) {
            return f16242.f15659.arrayBaseOffset(cls);
        }
        return -1;
    }

    /* renamed from: ᵴᵳ, reason: contains not printable characters */
    public static void m9311(Object obj, long j, byte b) {
        Unsafe unsafe = f16242.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 m9312(Object obj, long j, long j2) {
        f16242.f15659.putLong(obj, j, j2);
    }

    /* renamed from: ᵸˑ, reason: contains not printable characters */
    public static void m9313(Object obj, long j, Object obj2) {
        f16242.f15659.putObject(obj, j, obj2);
    }

    /* renamed from: ᵹᵝᵶ, reason: contains not printable characters */
    public static Unsafe m9314() {
        Unsafe unsafe;
        try {
            unsafe = (Unsafe) AccessController.doPrivileged(new C3320());
        } catch (Throwable unused) {
            unsafe = null;
        }
        if (unsafe == null) {
            return null;
        }
        try {
            unsafe.arrayBaseOffset(byte[].class);
            return unsafe;
        } catch (Exception unused2) {
            Logger.getLogger(AbstractC4335.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 int m9315(long j, Object obj) {
        return f16242.f15659.getInt(obj, j);
    }
}