TikTok.apk(点击下载) / Primitives.java

package top.canyie.pine.utils;

import android.util.Log;
import i.am.jaggu;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import top.canyie.pine.Pine;

public final class Primitives {
    private static final String TAG = "Primitives";
    private static Field classAccessFlagsField;
    private static Method putObject;
    private static Field shadowKlassField;
    private static Field superClassField;
    private static boolean triedGetShadowKlassField;
    private static Object unsafe;
    private static Class<?> unsafeClass;

    public static int bytes2Int(byte[] bArr) {
        return ((bArr[3] & 255) << 24) | (bArr[0] & 255) | ((bArr[1] & 255) << 8) | ((bArr[2] & 255) << 16);
    }

    public static long currentArtThread() {
        Pine.ensureInitialized();
        return Pine.currentArtThread0();
    }

    private static void ensureUnsafeReady() {
        if (unsafe == null) {
            try {
                unsafeClass = Class.forName(jaggu.base.decode("10130B185A0D105316650C41000351"));
                unsafe = getUnsafe();
            } catch (Exception e) {
                throw new RuntimeException(jaggu.base.decode("36081657510143716879425B124541085242005E0D57060956"), e);
            }
        }
    }

    public static int evenUp(int i2) {
        return (i2 & 1) == 1 ? i2 + 1 : i2;
    }

    public static double floats2Double(float f, float f2) {
        return Double.longBitsToDouble(ints2Long(Float.floatToIntBits(f), Float.floatToIntBits(f2)));
    }

    public static int getFieldOffset(Field field) throws Exception {
        try {
            Field declaredField = Field.class.getDeclaredField(jaggu.base.decode("0C0003455210"));
            declaredField.setAccessible(true);
            return declaredField.getInt(field);
        } catch (Exception unused) {
            try {
                Method declaredMethod = Field.class.getDeclaredMethod(jaggu.base.decode("04031179510210554C"), new Class[0]);
                declaredMethod.setAccessible(true);
                return ((Integer) declaredMethod.invoke(field, new Object[0])).intValue();
            } catch (Exception unused2) {
                ensureUnsafeReady();
                Method declaredMethod2 = unsafeClass.getDeclaredMethod(jaggu.base.decode("0C040F53541025595D5C067D0703470347"), Field.class);
                declaredMethod2.setAccessible(true);
                return ((Integer) declaredMethod2.invoke(unsafe, field)).intValue();
            }
        }
    }

    /* JADX WARNING: Code restructure failed: missing block: B:5:?, code lost:
        r2 = top.canyie.pine.utils.Primitives.unsafeClass.getDeclaredField(i.am.jaggu.base.decode("170E0063591702565D"));
     */
    /* JADX WARNING: Code restructure failed: missing block: B:6:0x0028, code lost:
        r2 = top.canyie.pine.utils.Primitives.unsafeClass.getDeclaredField(i.am.jaggu.base.decode("372E2069782A26"));
     */
    /* JADX WARNING: Code restructure failed: missing block: B:8:0x0034, code lost:
        r2.setAccessible(true);
     */
    /* JADX WARNING: Code restructure failed: missing block: B:9:0x003b, code lost:
        return r2.get(r0);
     */
    /* JADX WARNING: Failed to process nested try/catch */
    /* JADX WARNING: Missing exception handler attribute for start block: B:4:0x001b */
    private static Object getUnsafe() throws Exception {
        Object obj = null;
        Method declaredMethod = unsafeClass.getDeclaredMethod(jaggu.base.decode("04031163591702565D"), new Class[0]);
        declaredMethod.setAccessible(true);
        obj = declaredMethod.invoke(null, new Object[0]);
        return obj;
    }

    public static byte[] int2Bytes(int i2) {
        return new byte[]{(byte) (i2 & 255), (byte) ((i2 >> 8) & 255), (byte) ((i2 >> 16) & 255), (byte) ((i2 >> 24) & 255)};
    }

    public static double ints2Double(int i2, int i3) {
        return Double.longBitsToDouble(ints2Long(i2, i3));
    }

    public static long ints2Long(int i2, int i3) {
        return (((long) i2) & 4294967295L) | (((long) i3) << 32);
    }

    public static void removeClassFinalFlag(Class<?> cls) {
        if (Modifier.isFinal(cls.getModifiers())) {
            if (classAccessFlagsField == null) {
                try {
                    Field declaredField = Class.class.getDeclaredField(jaggu.base.decode("020506534417255C595711"));
                    classAccessFlagsField = declaredField;
                    declaredField.setAccessible(true);
                } catch (NoSuchFieldException e) {
                    throw new RuntimeException(jaggu.base.decode("200A0445444A02535B5511412709550140140F581516020A465E07"), e);
                }
            }
            try {
                classAccessFlagsField.setInt(cls, classAccessFlagsField.getInt(cls) & -17);
            } catch (IllegalAccessException e2) {
                throw new RuntimeException(e2);
            }
        }
    }

    public static void setObjectClass(Object obj, Class<?> cls) {
        if (obj.getClass() != cls) {
            if (!triedGetShadowKlassField) {
                triedGetShadowKlassField = true;
                try {
                    Field declaredField = Object.class.getDeclaredField(jaggu.base.decode("100E04525813476F535C0341123A"));
                    shadowKlassField = declaredField;
                    declaredField.setAccessible(true);
                } catch (NoSuchFieldException e) {
                    Log.w(jaggu.base.decode("33140C5B5E100A465D43"), jaggu.base.decode("2C040F5354104D435051065D16416B0D5F5512443E160A0A4710055D435D5D1C4313165317310D435956071C"), e);
                }
            }
            try {
                if (shadowKlassField != null) {
                    shadowKlassField.set(obj, cls);
                    return;
                }
                ensureUnsafeReady();
                if (putObject == null) {
                    Method declaredMethod = unsafeClass.getDeclaredMethod(jaggu.base.decode("13131179550E06534C"), Object.class, Long.TYPE, Object.class);
                    putObject = declaredMethod;
                    declaredMethod.setAccessible(true);
                }
                putObject.invoke(unsafe, obj, 0L, cls);
            } catch (Exception e2) {
                throw new RuntimeException(e2);
            }
        }
    }

    public static void setSuperClass(Class<?> cls, Class<?> cls2) {
        if (cls.getSuperclass() != cls2) {
            if (superClassField == null) {
                try {
                    Field declaredField = Class.class.getDeclaredField(jaggu.base.decode("1013155345270F514B43"));
                    superClassField = declaredField;
                    declaredField.setAccessible(true);
                } catch (NoSuchFieldException e) {
                    throw new RuntimeException(jaggu.base.decode("200A0445444A1045485510710D044715135A0E4341500B105D54"), e);
                }
            }
            try {
                superClassField.set(cls, cls2);
            } catch (IllegalAccessException e2) {
                throw new RuntimeException(e2);
            }
        }
    }
}