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;

/* JADX INFO: renamed from: ᵷˑᵣ, reason: contains not printable characters */
/* JADX INFO: loaded from: classes3.dex */
public abstract class AbstractC4892 {

    /* JADX INFO: renamed from: ʽˈˋ, reason: contains not printable characters */
    public static final Class f18619;

    /* JADX INFO: renamed from: ːˏᵟᵯ, reason: contains not printable characters */
    public static final AbstractC0330 f18620;

    /* JADX INFO: renamed from: ᵨᵣ, reason: contains not printable characters */
    public static final boolean f18621;

    /* JADX INFO: renamed from: ᵲᵶᵳˈ, reason: contains not printable characters */
    public static final Unsafe f18622;

    /* JADX INFO: renamed from: ᵷᵺʾᵖ, reason: contains not printable characters */
    public static final boolean f18623;

    /* JADX WARN: Multi-variable type inference failed */
    static {
        char c;
        boolean z;
        AbstractC0330 abstractC0330;
        Unsafe unsafeM10166 = m10166();
        f18622 = unsafeM10166;
        int i = AbstractC5348.f20178;
        f18619 = Memory.class;
        Class<?> cls = Long.TYPE;
        boolean zM10164 = m10164(cls);
        Class<?> cls2 = Integer.TYPE;
        boolean zM101642 = m10164(cls2);
        AbstractC0330 c5396 = null;
        if (unsafeM10166 != null) {
            if (zM10164) {
                c5396 = new C3033(unsafeM10166);
            } else if (zM101642) {
                c5396 = new C5396(unsafeM10166);
            }
        }
        f18620 = c5396;
        if (c5396 != null) {
            try {
                Class<?> cls3 = c5396.f2052.getClass();
                cls3.getMethod("objectFieldOffset", Field.class);
                cls3.getMethod("getLong", Object.class, cls);
                m10165();
                c = 0;
            } catch (Throwable th) {
                c = 0;
                Logger.getLogger(AbstractC4892.class.getName()).logp(Level.WARNING, "com.google.protobuf.UnsafeUtil", "logMissingMethod", "platform method missing - proto runtime falling back to safer methods: ".concat(th.toString()));
            }
        } else {
            c = 0;
        }
        AbstractC0330 abstractC03302 = f18620;
        if (abstractC03302 == null) {
            z = c;
        } else {
            try {
                Class<?> cls4 = abstractC03302.f2052.getClass();
                Class<?>[] clsArr = new Class[1];
                clsArr[c] = Field.class;
                cls4.getMethod("objectFieldOffset", clsArr);
                Class<?>[] clsArr2 = new Class[1];
                clsArr2[c] = Class.class;
                cls4.getMethod("arrayBaseOffset", clsArr2);
                Class<?>[] clsArr3 = new Class[1];
                clsArr3[c] = Class.class;
                cls4.getMethod("arrayIndexScale", clsArr3);
                Class<?>[] clsArr4 = new Class[2];
                clsArr4[c] = Object.class;
                clsArr4[1] = cls;
                cls4.getMethod("getInt", clsArr4);
                Class<?>[] clsArr5 = new Class[3];
                clsArr5[c] = Object.class;
                clsArr5[1] = cls;
                clsArr5[2] = cls2;
                cls4.getMethod("putInt", clsArr5);
                Class<?>[] clsArr6 = new Class[2];
                clsArr6[c] = Object.class;
                clsArr6[1] = cls;
                cls4.getMethod("getLong", clsArr6);
                Class<?>[] clsArr7 = new Class[3];
                clsArr7[c] = Object.class;
                clsArr7[1] = cls;
                clsArr7[2] = cls;
                cls4.getMethod("putLong", clsArr7);
                Class<?>[] clsArr8 = new Class[2];
                clsArr8[c] = Object.class;
                clsArr8[1] = cls;
                cls4.getMethod("getObject", clsArr8);
                Class<?>[] clsArr9 = new Class[3];
                clsArr9[c] = Object.class;
                clsArr9[1] = cls;
                clsArr9[2] = Object.class;
                cls4.getMethod("putObject", clsArr9);
                z = 1;
            } catch (Throwable th2) {
                Logger.getLogger(AbstractC4892.class.getName()).logp(Level.WARNING, "com.google.protobuf.UnsafeUtil", "logMissingMethod", "platform method missing - proto runtime falling back to safer methods: ".concat(th2.toString()));
                z = c;
            }
        }
        f18623 = z;
        m10162(byte[].class);
        m10162(boolean[].class);
        m10167(boolean[].class);
        m10162(int[].class);
        m10167(int[].class);
        m10162(long[].class);
        m10167(long[].class);
        m10162(float[].class);
        m10167(float[].class);
        m10162(double[].class);
        m10167(double[].class);
        m10162(Object[].class);
        m10167(Object[].class);
        Field fieldM10165 = m10165();
        if (fieldM10165 != null && (abstractC0330 = f18620) != null) {
            abstractC0330.f2052.objectFieldOffset(fieldM10165);
        }
        f18621 = ByteOrder.nativeOrder() != ByteOrder.BIG_ENDIAN ? c : 1;
    }

    /* JADX INFO: renamed from: ʽˈˋ, reason: contains not printable characters */
    public static long m10160(long j, Object obj) {
        return f18620.f2052.getLong(obj, j);
    }

    /* JADX INFO: renamed from: ˊᵫᵗ, reason: contains not printable characters */
    public static void m10161(long j, Object obj, int i) {
        f18620.f2052.putInt(obj, j, i);
    }

    /* JADX INFO: renamed from: ˋˈ, reason: contains not printable characters */
    public static void m10162(Class cls) {
        if (f18623) {
            f18620.f2052.arrayBaseOffset(cls);
        }
    }

    /* JADX INFO: renamed from: ːˏᵟᵯ, reason: contains not printable characters */
    public static Object m10163(Class cls) {
        try {
            return f18622.allocateInstance(cls);
        } catch (InstantiationException e) {
            C1418.m4090(e);
            return null;
        }
    }

    /* JADX WARN: Multi-variable type inference failed */
    /* JADX INFO: renamed from: ᵝᵶ, reason: contains not printable characters */
    public static boolean m10164(Class cls) {
        int i = AbstractC5348.f20178;
        try {
            Class cls2 = f18619;
            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;
        }
    }

    /* JADX INFO: renamed from: ᵟᵹᵙ, reason: contains not printable characters */
    public static Field m10165() {
        Field declaredField;
        Field declaredField2;
        int i = AbstractC5348.f20178;
        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 INFO: renamed from: ᵨᵣ, reason: contains not printable characters */
    public static Unsafe m10166() {
        Unsafe unsafe;
        try {
            unsafe = (Unsafe) AccessController.doPrivileged(new C3121());
        } catch (Throwable unused) {
            unsafe = null;
        }
        if (unsafe == null) {
            return null;
        }
        try {
            unsafe.arrayBaseOffset(byte[].class);
            return unsafe;
        } catch (Exception unused2) {
            Logger.getLogger(AbstractC4892.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;
        }
    }

    /* JADX INFO: renamed from: ᵪᵹᵥᵻ, reason: contains not printable characters */
    public static void m10167(Class cls) {
        if (f18623) {
            f18620.f2052.arrayIndexScale(cls);
        }
    }

    /* JADX INFO: renamed from: ᵮᵣᵗˈ, reason: contains not printable characters */
    public static /* bridge */ /* synthetic */ boolean m10168(long j, Object obj) {
        return ((byte) ((f18620.f2052.getInt(obj, (-4) & j) >>> ((int) ((j & 3) << 3))) & 255)) != 0;
    }

    /* JADX INFO: renamed from: ᵱᵽʡᵚ, reason: contains not printable characters */
    public static void m10169(Object obj, long j, Object obj2) {
        f18620.f2052.putObject(obj, j, obj2);
    }

    /* JADX INFO: renamed from: ᵲᵶᵳˈ, reason: contains not printable characters */
    public static int m10170(long j, Object obj) {
        return f18620.f2052.getInt(obj, j);
    }

    /* JADX INFO: renamed from: ᵵᵽ, reason: contains not printable characters */
    public static /* synthetic */ void m10171(Object obj, long j, boolean z) {
        Unsafe unsafe = f18620.f2052;
        long j2 = (-4) & j;
        int i = (((int) j) & 3) << 3;
        unsafe.putInt(obj, j2, ((z ? 1 : 0) << i) | ((~(255 << i)) & unsafe.getInt(obj, j2)));
    }

    /* JADX INFO: renamed from: ᵶᵥᵝ, reason: contains not printable characters */
    public static /* bridge */ /* synthetic */ boolean m10172(long j, Object obj) {
        return ((byte) ((f18620.f2052.getInt(obj, (-4) & j) >>> ((int) (((~j) & 3) << 3))) & 255)) != 0;
    }

    /* JADX INFO: renamed from: ᵷᵺʾᵖ, reason: contains not printable characters */
    public static Object m10173(long j, Object obj) {
        return f18620.f2052.getObject(obj, j);
    }

    /* JADX INFO: renamed from: ᵻʽᵯ, reason: contains not printable characters */
    public static void m10174(Object obj, long j, long j2) {
        f18620.f2052.putLong(obj, j, j2);
    }

    /* JADX INFO: renamed from: ᵻˈᵦʼ, reason: contains not printable characters */
    public static /* synthetic */ void m10175(Object obj, long j, boolean z) {
        Unsafe unsafe = f18620.f2052;
        long j2 = (-4) & j;
        int i = unsafe.getInt(obj, j2);
        int i2 = ((~((int) j)) & 3) << 3;
        unsafe.putInt(obj, j2, ((z ? 1 : 0) << i2) | ((~(255 << i2)) & i));
    }
}