package com.google.android.gms.internal.measurement;

import java.lang.reflect.Field;
import java.nio.Buffer;
import java.nio.ByteOrder;
import java.security.AccessController;
import sun.misc.Unsafe;

/* JADX INFO: loaded from: classes2.dex */
public abstract class j7 {

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public static final Unsafe f20259a;

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public static final Class f20260b;

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public static final h7 f20261c;

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    public static final boolean f20262d;

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    public static final boolean f20263e;

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    public static final long f20264f;

    /* JADX INFO: renamed from: g, reason: collision with root package name */
    public static final boolean f20265g;

    /* JADX WARN: Removed duplicated region for block: B:8:0x002b  */
    static {
        h7 h7Var;
        Field declaredField;
        Field declaredField2;
        Unsafe unsafeJ = j();
        f20259a = unsafeJ;
        f20260b = p5.f20364a;
        boolean zO = o(Long.TYPE);
        boolean zO2 = o(Integer.TYPE);
        Field field = null;
        if (unsafeJ == null) {
            h7Var = null;
        } else if (zO) {
            h7Var = new h7(unsafeJ, 1);
        } else if (zO2) {
            h7Var = new h7(unsafeJ, 0);
        }
        f20261c = h7Var;
        f20262d = h7Var == null ? false : h7Var.d();
        f20263e = h7Var == null ? false : h7Var.c();
        f20264f = i(byte[].class);
        i(boolean[].class);
        k(boolean[].class);
        i(int[].class);
        k(int[].class);
        i(long[].class);
        k(long[].class);
        i(float[].class);
        k(float[].class);
        i(double[].class);
        k(double[].class);
        i(Object[].class);
        k(Object[].class);
        try {
            declaredField = Buffer.class.getDeclaredField("effectiveDirectAddress");
        } catch (Throwable unused) {
            declaredField = null;
        }
        if (declaredField != null) {
            field = declaredField;
        } else {
            try {
                declaredField2 = Buffer.class.getDeclaredField("address");
            } catch (Throwable unused2) {
                declaredField2 = null;
            }
            if (declaredField2 != null && declaredField2.getType() == Long.TYPE) {
                field = declaredField2;
            }
        }
        if (field != null && h7Var != null) {
            h7Var.f20237a.objectFieldOffset(field);
        }
        f20265g = ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN;
    }

    public static double a(Object obj, long j10) {
        h7 h7Var = f20261c;
        switch (h7Var.f20219b) {
        }
        return Double.longBitsToDouble(h7Var.f(j10, obj));
    }

    public static Object b(Class cls) {
        try {
            return f20259a.allocateInstance(cls);
        } catch (InstantiationException e10) {
            throw new IllegalStateException(e10);
        }
    }

    public static void c(int i10, long j10, Object obj) {
        f20261c.a(i10, j10, obj);
    }

    public static void d(Object obj, long j10, double d10) {
        h7 h7Var = f20261c;
        switch (h7Var.f20219b) {
            case 0:
                h7Var.b(obj, j10, Double.doubleToLongBits(d10));
                break;
            default:
                h7Var.b(obj, j10, Double.doubleToLongBits(d10));
                break;
        }
    }

    public static void e(Object obj, long j10, float f10) {
        h7 h7Var = f20261c;
        switch (h7Var.f20219b) {
            case 0:
                h7Var.a(Float.floatToIntBits(f10), j10, obj);
                break;
            default:
                h7Var.a(Float.floatToIntBits(f10), j10, obj);
                break;
        }
    }

    public static void f(Object obj, long j10, Object obj2) {
        f20261c.f20237a.putObject(obj, j10, obj2);
    }

    public static void g(byte[] bArr, long j10, byte b10) {
        long j11 = f20264f + j10;
        int i10 = f20261c.f20219b;
        boolean z10 = f20265g;
        switch (i10) {
            case 0:
                if (!z10) {
                    n(bArr, j11, b10);
                } else {
                    l(bArr, j11, b10);
                }
                break;
            default:
                if (!z10) {
                    n(bArr, j11, b10);
                } else {
                    l(bArr, j11, b10);
                }
                break;
        }
    }

    public static float h(Object obj, long j10) {
        h7 h7Var = f20261c;
        switch (h7Var.f20219b) {
        }
        return Float.intBitsToFloat(h7Var.e(j10, obj));
    }

    public static int i(Class cls) {
        if (f20263e) {
            return f20261c.f20237a.arrayBaseOffset(cls);
        }
        return -1;
    }

    public static Unsafe j() {
        try {
            return (Unsafe) AccessController.doPrivileged(new k7());
        } catch (Throwable unused) {
            return null;
        }
    }

    public static void k(Class cls) {
        if (f20263e) {
            f20261c.f20237a.arrayIndexScale(cls);
        }
    }

    public static void l(Object obj, long j10, byte b10) {
        long j11 = (-4) & j10;
        int iE = f20261c.e(j11, obj);
        int i10 = ((~((int) j10)) & 3) << 3;
        c(((255 & b10) << i10) | (iE & (~(255 << i10))), j11, obj);
    }

    public static void m(Object obj, long j10, boolean z10) {
        int i10 = f20261c.f20219b;
        boolean z11 = f20265g;
        switch (i10) {
            case 0:
                if (!z11) {
                    n(obj, j10, z10 ? (byte) 1 : (byte) 0);
                } else {
                    l(obj, j10, z10 ? (byte) 1 : (byte) 0);
                }
                break;
            default:
                if (!z11) {
                    n(obj, j10, z10 ? (byte) 1 : (byte) 0);
                } else {
                    l(obj, j10, z10 ? (byte) 1 : (byte) 0);
                }
                break;
        }
    }

    public static void n(Object obj, long j10, byte b10) {
        long j11 = (-4) & j10;
        int i10 = (((int) j10) & 3) << 3;
        c(((255 & b10) << i10) | (f20261c.e(j11, obj) & (~(255 << i10))), j11, obj);
    }

    /* JADX WARN: Multi-variable type inference failed */
    public static boolean o(Class cls) {
        try {
            Class cls2 = f20260b;
            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;
        }
    }

    public static Object p(long j10, Object obj) {
        return f20261c.f20237a.getObject(obj, j10);
    }

    public static boolean q(long j10, Object obj) {
        h7 h7Var = f20261c;
        int i10 = h7Var.f20219b;
        boolean z10 = f20265g;
        switch (i10) {
            case 0:
                if (z10) {
                    if (((byte) (h7Var.e((-4) & j10, obj) >>> ((int) (((~j10) & 3) << 3)))) == 0) {
                        return false;
                    }
                } else if (((byte) (h7Var.e((-4) & j10, obj) >>> ((int) ((j10 & 3) << 3)))) == 0) {
                    return false;
                }
            default:
                if (z10) {
                    if (((byte) (h7Var.e((-4) & j10, obj) >>> ((int) (((~j10) & 3) << 3)))) == 0) {
                        return false;
                    }
                } else if (((byte) (h7Var.e((-4) & j10, obj) >>> ((int) ((j10 & 3) << 3)))) == 0) {
                    return false;
                }
        }
        return true;
    }
}