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

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

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

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

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

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

    /* JADX INFO: renamed from: ᵻˈᵦʼ, reason: contains not printable characters */
    public static final boolean f17526;

    /* JADX WARN: Multi-variable type inference failed */
    static {
        char c;
        boolean z;
        AbstractC0330 abstractC0330;
        Unsafe unsafeM9712 = m9712();
        f17524 = unsafeM9712;
        int i = AbstractC1986.f7873;
        f17521 = Memory.class;
        Class<?> cls = Long.TYPE;
        boolean zM9708 = m9708(cls);
        Class<?> cls2 = Integer.TYPE;
        boolean zM97082 = m9708(cls2);
        AbstractC0330 c0056 = null;
        if (unsafeM9712 != null) {
            if (zM9708) {
                c0056 = new C3303(unsafeM9712);
            } else if (zM97082) {
                c0056 = new C0056(unsafeM9712);
            }
        }
        f17522 = c0056;
        if (c0056 != null) {
            try {
                Class<?> cls3 = c0056.f2052.getClass();
                cls3.getMethod("objectFieldOffset", Field.class);
                cls3.getMethod("getLong", Object.class, cls);
                m9715();
                c = 0;
            } catch (Throwable th) {
                c = 0;
                Logger.getLogger(AbstractC4609.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 = f17522;
        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(AbstractC4609.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;
            }
        }
        f17525 = z;
        f17523 = m9709(byte[].class);
        m9709(boolean[].class);
        m9713(boolean[].class);
        m9709(int[].class);
        m9713(int[].class);
        m9709(long[].class);
        m9713(long[].class);
        m9709(float[].class);
        m9713(float[].class);
        m9709(double[].class);
        m9713(double[].class);
        m9709(Object[].class);
        m9713(Object[].class);
        Field fieldM9715 = m9715();
        if (fieldM9715 != null && (abstractC0330 = f17522) != null) {
            abstractC0330.f2052.objectFieldOffset(fieldM9715);
        }
        f17526 = ByteOrder.nativeOrder() != ByteOrder.BIG_ENDIAN ? c : 1;
    }

    /* JADX INFO: renamed from: ʽˈˋ, reason: contains not printable characters */
    public static void m9704(Object obj, long j, byte b) {
        Unsafe unsafe = f17522.f2052;
        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))));
    }

    /* JADX INFO: renamed from: ˊᵫᵗ, reason: contains not printable characters */
    public static void m9705(Object obj, long j, long j2) {
        f17522.f2052.putLong(obj, j, j2);
    }

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

    /* JADX INFO: renamed from: ːˏᵟᵯ, reason: contains not printable characters */
    public static void m9707(Object obj, long j, byte b) {
        Unsafe unsafe = f17522.f2052;
        long j2 = (-4) & j;
        int i = (((int) j) & 3) << 3;
        unsafe.putInt(obj, j2, ((255 & b) << i) | (unsafe.getInt(obj, j2) & (~(255 << i))));
    }

    /* JADX WARN: Multi-variable type inference failed */
    /* JADX INFO: renamed from: ᵝᵶ, reason: contains not printable characters */
    public static boolean m9708(Class cls) {
        int i = AbstractC1986.f7873;
        try {
            Class cls2 = f17521;
            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 int m9709(Class cls) {
        if (f17525) {
            return f17522.f2052.arrayBaseOffset(cls);
        }
        return -1;
    }

    /* JADX INFO: renamed from: ᵨᵣ, reason: contains not printable characters */
    public static int m9710(long j, Object obj) {
        return f17522.f2052.getInt(obj, j);
    }

    /* JADX INFO: renamed from: ᵪᵹᵥᵻ, reason: contains not printable characters */
    public static /* synthetic */ boolean m9711(long j, Object obj) {
        return ((byte) ((f17522.f2052.getInt(obj, (-4) & j) >>> ((int) ((j & 3) << 3))) & 255)) != 0;
    }

    /* JADX INFO: renamed from: ᵮᵣᵗˈ, reason: contains not printable characters */
    public static Unsafe m9712() {
        Unsafe unsafe;
        try {
            unsafe = (Unsafe) AccessController.doPrivileged(new C1133());
        } catch (Throwable unused) {
            unsafe = null;
        }
        if (unsafe == null) {
            return null;
        }
        try {
            unsafe.arrayBaseOffset(byte[].class);
            return unsafe;
        } catch (Exception unused2) {
            Logger.getLogger(AbstractC4609.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 m9713(Class cls) {
        if (f17525) {
            f17522.f2052.arrayIndexScale(cls);
        }
    }

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

    /* JADX INFO: renamed from: ᵲᵶᵳˈ, reason: contains not printable characters */
    public static Field m9715() {
        Field declaredField;
        Field declaredField2;
        int i = AbstractC1986.f7873;
        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 long m9716(long j, Object obj) {
        return f17522.f2052.getLong(obj, j);
    }

    /* JADX INFO: renamed from: ᵶᵥᵝ, reason: contains not printable characters */
    public static void m9717(byte[] bArr, long j, byte b) {
        f17522.mo1065(bArr, f17523 + j, b);
    }

    /* JADX INFO: renamed from: ᵷᵺʾᵖ, reason: contains not printable characters */
    public static Object m9718(Class cls) {
        try {
            return f17524.allocateInstance(cls);
        } catch (InstantiationException e) {
            C1418.m4090(e);
            return null;
        }
    }

    /* JADX INFO: renamed from: ᵻʽᵯ, reason: contains not printable characters */
    public static Object m9719(long j, Object obj) {
        return f17522.f2052.getObject(obj, j);
    }

    /* JADX INFO: renamed from: ᵻˈᵦʼ, reason: contains not printable characters */
    public static void m9720(long j, Object obj, int i) {
        f17522.f2052.putInt(obj, j, i);
    }
}