package andhook.lib.xposed;
import andhook.lib.xposed.XC_MethodHook;
import android.content.res.Resources;
import android.util.Log;
import com.ss.android.ugc.effectmanager.common.utils.FileUtils;
import com.swift.sandhook.utils.FileUtils;
import dalvik.system.DexFile;
import i.am.jaggu;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.WeakHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.zip.ZipFile;
public final class XposedHelpers {
private static final String LOGTAG = "XposedHelpers";
private static final WeakHashMap<Object, HashMap<String, Object>> additionalFields = new WeakHashMap<>();
private static final HashMap<String, Constructor<?>> constructorCache = new HashMap<>();
private static final HashMap<String, Field> fieldCache = new HashMap<>();
private static final HashMap<String, Method> methodCache = new HashMap<>();
private static final HashMap<String, ThreadLocal<AtomicInteger>> sMethodDepth = new HashMap<>();
public static final class ClassNotFoundError extends Error {
private static final long serialVersionUID = -1070936889459514628L;
public ClassNotFoundError(String str, Throwable th) {
super(str, th);
}
public ClassNotFoundError(Throwable th) {
super(th);
}
}
public static final class InvocationTargetError extends Error {
private static final long serialVersionUID = -1070936889459514628L;
public InvocationTargetError(Throwable th) {
super(th);
}
}
public static byte[] assetAsByteArray(Resources resources, String str) throws IOException {
return inputStreamToByteArray(resources.getAssets().open(str));
}
public static Object callMethod(Object obj, String str, Class<?>[] clsArr, Object... objArr) {
try {
return findMethodBestMatch(obj.getClass(), str, clsArr, objArr).invoke(obj, objArr);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
} catch (InvocationTargetException e3) {
throw new InvocationTargetError(e3.getCause());
}
}
public static Object callMethod(Object obj, String str, Object... objArr) {
try {
return findMethodBestMatch(obj.getClass(), str, objArr).invoke(obj, objArr);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
} catch (InvocationTargetException e3) {
throw new InvocationTargetError(e3.getCause());
}
}
public static Object callStaticMethod(Class<?> cls, String str, Class<?>[] clsArr, Object... objArr) {
try {
return findMethodBestMatch(cls, str, clsArr, objArr).invoke(null, objArr);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
} catch (InvocationTargetException e3) {
throw new InvocationTargetError(e3.getCause());
}
}
public static Object callStaticMethod(Class<?> cls, String str, Object... objArr) {
try {
return findMethodBestMatch(cls, str, objArr).invoke(null, objArr);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
} catch (InvocationTargetException e3) {
throw new InvocationTargetError(e3.getCause());
}
}
static void closeSilently(DexFile dexFile) {
if (dexFile != null) {
try {
dexFile.close();
} catch (IOException unused) {
}
}
}
static void closeSilently(Closeable closeable) {
if (closeable != null) {
try {
closeable.close();
} catch (IOException unused) {
}
}
}
static void closeSilently(ZipFile zipFile) {
if (zipFile != null) {
try {
zipFile.close();
} catch (IOException unused) {
}
}
}
public static int decrementMethodDepth(String str) {
return getMethodDepthCounter(str).get().decrementAndGet();
}
static boolean fileContains(File file, String str) throws IOException {
Throwable th;
boolean z;
BufferedReader bufferedReader = null;
try {
BufferedReader bufferedReader2 = new BufferedReader(new FileReader(file));
while (true) {
try {
String readLine = bufferedReader2.readLine();
if (readLine != null) {
if (readLine.contains(str)) {
z = true;
break;
}
} else {
z = false;
break;
}
} catch (Throwable th2) {
th = th2;
bufferedReader = bufferedReader2;
closeSilently(bufferedReader);
throw th;
}
}
closeSilently(bufferedReader2);
return z;
} catch (Throwable th3) {
th = th3;
closeSilently(bufferedReader);
throw th;
}
}
public static XC_MethodHook.Unhook findAndHookConstructor(Class<?> cls, Object... objArr) {
if (objArr.length == 0 || !(objArr[objArr.length - 1] instanceof XC_MethodHook)) {
throw new IllegalArgumentException(jaggu.base.decode("0D09455556080F52595309120500520F5D5105"));
}
return XposedBridge.hookMethod(findConstructorExact(cls, getParameterClasses(cls.getClassLoader(), objArr)), (XC_MethodHook) objArr[objArr.length - 1]);
}
public static XC_MethodHook.Unhook findAndHookConstructor(String str, ClassLoader classLoader, Object... objArr) {
return findAndHookConstructor(findClass(str, classLoader), objArr);
}
public static XC_MethodHook.Unhook findAndHookMethod(Class<?> cls, String str, Object... objArr) {
if (objArr.length == 0 || !(objArr[objArr.length - 1] instanceof XC_MethodHook)) {
throw new IllegalArgumentException(jaggu.base.decode("0D09455556080F52595309120500520F5D5105"));
}
return XposedBridge.hookMethod(findMethodExact(cls, str, getParameterClasses(cls.getClassLoader(), objArr)), (XC_MethodHook) objArr[objArr.length - 1]);
}
public static XC_MethodHook.Unhook findAndHookMethod(String str, ClassLoader classLoader, String str2, Object... objArr) {
return findAndHookMethod(findClass(str, classLoader), str2, objArr);
}
public static Class<?> findClass(String str, ClassLoader classLoader) {
if (classLoader == null) {
classLoader = ClassLoader.getSystemClassLoader();
}
try {
return classLoader.loadClass(str);
} catch (ClassNotFoundException e) {
throw new ClassNotFoundError(e);
}
}
public static Class<?> findClassIfExists(String str, ClassLoader classLoader) {
try {
return findClass(str, classLoader);
} catch (ClassNotFoundError unused) {
return null;
}
}
public static Constructor<?> findConstructorBestMatch(Class<?> cls, Class<?>... clsArr) {
String str = cls.getName() + getParametersString(clsArr) + jaggu.base.decode("40040045430902445B58");
if (constructorCache.containsKey(str)) {
Constructor<?> constructor = constructorCache.get(str);
if (constructor != null) {
return constructor;
}
throw new NoSuchMethodError(str);
}
try {
Constructor<?> findConstructorExact = findConstructorExact(cls, clsArr);
constructorCache.put(str, findConstructorExact);
return findConstructorExact;
} catch (NoSuchMethodError unused) {
Constructor<?>[] declaredConstructors = cls.getDeclaredConstructors();
Constructor<?> constructor2 = null;
for (Constructor<?> constructor3 : declaredConstructors) {
if (ClassUtils.isAssignable(clsArr, constructor3.getParameterTypes(), true) && (constructor2 == null || MemberUtils.compareParameterTypes(constructor3.getParameterTypes(), constructor2.getParameterTypes(), clsArr) < 0)) {
constructor2 = constructor3;
}
}
if (constructor2 != null) {
constructor2.setAccessible(true);
constructorCache.put(str, constructor2);
return constructor2;
}
constructorCache.put(str, null);
throw new NoSuchMethodError(str);
}
}
public static Constructor<?> findConstructorBestMatch(Class<?> cls, Class<?>[] clsArr, Object[] objArr) {
Class<?>[] clsArr2 = null;
for (int i2 = 0; i2 < clsArr.length; i2++) {
if (clsArr[i2] == null) {
if (clsArr2 == null) {
clsArr2 = getParameterTypes(objArr);
}
clsArr[i2] = clsArr2[i2];
}
}
return findConstructorBestMatch(cls, clsArr);
}
public static Constructor<?> findConstructorBestMatch(Class<?> cls, Object... objArr) {
return findConstructorBestMatch(cls, getParameterTypes(objArr));
}
public static Constructor<?> findConstructorExact(Class<?> cls, Class<?>... clsArr) {
String str = cls.getName() + getParametersString(clsArr) + jaggu.base.decode("40031D575410");
if (constructorCache.containsKey(str)) {
Constructor<?> constructor = constructorCache.get(str);
if (constructor != null) {
return constructor;
}
throw new NoSuchMethodError(str);
}
try {
Constructor<?> declaredConstructor = cls.getDeclaredConstructor(clsArr);
declaredConstructor.setAccessible(true);
constructorCache.put(str, declaredConstructor);
return declaredConstructor;
} catch (NoSuchMethodException unused) {
constructorCache.put(str, null);
throw new NoSuchMethodError(str);
}
}
public static Constructor<?> findConstructorExact(Class<?> cls, Object... objArr) {
return findConstructorExact(cls, getParameterClasses(cls.getClassLoader(), objArr));
}
public static Constructor<?> findConstructorExact(String str, ClassLoader classLoader, Object... objArr) {
return findConstructorExact(findClass(str, classLoader), getParameterClasses(classLoader, objArr));
}
public static Constructor<?> findConstructorExactIfExists(Class<?> cls, Object... objArr) {
try {
return findConstructorExact(cls, objArr);
} catch (ClassNotFoundError | NoSuchMethodError unused) {
return null;
}
}
public static Constructor<?> findConstructorExactIfExists(String str, ClassLoader classLoader, Object... objArr) {
try {
return findConstructorExact(str, classLoader, objArr);
} catch (ClassNotFoundError | NoSuchMethodError unused) {
return null;
}
}
public static Field findField(Class<?> cls, String str) {
String str2 = cls.getName() + '#' + str;
if (fieldCache.containsKey(str2)) {
Field field = fieldCache.get(str2);
if (field != null) {
return field;
}
throw new NoSuchFieldError(str2);
}
try {
Field findFieldRecursiveImpl = findFieldRecursiveImpl(cls, str);
findFieldRecursiveImpl.setAccessible(true);
fieldCache.put(str2, findFieldRecursiveImpl);
return findFieldRecursiveImpl;
} catch (NoSuchFieldException unused) {
fieldCache.put(str2, null);
throw new NoSuchFieldError(str2);
}
}
public static Field findFieldIfExists(Class<?> cls, String str) {
try {
return findField(cls, str);
} catch (NoSuchFieldError unused) {
return null;
}
}
private static Field findFieldRecursiveImpl(Class<?> cls, String str) throws NoSuchFieldException {
try {
return cls.getDeclaredField(str);
} catch (NoSuchFieldException e) {
while (true) {
cls = cls.getSuperclass();
if (cls == null || cls.equals(Object.class)) {
throw e;
}
try {
return cls.getDeclaredField(str);
} catch (NoSuchFieldException unused) {
}
}
throw e;
}
}
public static Field findFirstFieldByExactType(Class<?> cls, Class<?> cls2) {
Class<?> cls3 = cls;
do {
Field[] declaredFields = cls3.getDeclaredFields();
for (Field field : declaredFields) {
if (field.getType() == cls2) {
field.setAccessible(true);
return field;
}
}
cls3 = cls3.getSuperclass();
} while (cls3 != null);
throw new NoSuchFieldError(jaggu.base.decode("250F005A53440C5618441B420445") + cls2.getName() + jaggu.base.decode("430F0B16540802434B10") + cls.getName());
}
public static Method findMethodBestMatch(Class<?> cls, String str, Class<?>... clsArr) {
String str2 = cls.getName() + '#' + str + getParametersString(clsArr) + jaggu.base.decode("40040045430902445B58");
if (methodCache.containsKey(str2)) {
Method method = methodCache.get(str2);
if (method != null) {
return method;
}
throw new NoSuchMethodError(str2);
}
try {
Method findMethodExact = findMethodExact(cls, str, clsArr);
methodCache.put(str2, findMethodExact);
return findMethodExact;
} catch (NoSuchMethodError unused) {
Method method2 = null;
boolean z = true;
while (true) {
Method[] declaredMethods = cls.getDeclaredMethods();
for (Method method3 : declaredMethods) {
if ((z || !Modifier.isPrivate(method3.getModifiers())) && method3.getName().equals(str) && ClassUtils.isAssignable(clsArr, method3.getParameterTypes(), true) && (method2 == null || MemberUtils.compareParameterTypes(method3.getParameterTypes(), method2.getParameterTypes(), clsArr) < 0)) {
method2 = method3;
}
}
cls = cls.getSuperclass();
if (cls == null) {
break;
}
z = false;
}
if (method2 != null) {
method2.setAccessible(true);
methodCache.put(str2, method2);
return method2;
}
NoSuchMethodError noSuchMethodError = new NoSuchMethodError(str2);
methodCache.put(str2, null);
throw noSuchMethodError;
}
}
public static Method findMethodBestMatch(Class<?> cls, String str, Class<?>[] clsArr, Object[] objArr) {
Class<?>[] clsArr2 = null;
for (int i2 = 0; i2 < clsArr.length; i2++) {
if (clsArr[i2] == null) {
if (clsArr2 == null) {
clsArr2 = getParameterTypes(objArr);
}
clsArr[i2] = clsArr2[i2];
}
}
return findMethodBestMatch(cls, str, clsArr);
}
public static Method findMethodBestMatch(Class<?> cls, String str, Object... objArr) {
return findMethodBestMatch(cls, str, getParameterTypes(objArr));
}
public static Method findMethodExact(Class<?> cls, String str, Class<?>... clsArr) {
String str2 = cls.getName() + '#' + str + getParametersString(clsArr) + jaggu.base.decode("40031D575410");
if (methodCache.containsKey(str2)) {
Method method = methodCache.get(str2);
if (method != null) {
return method;
}
throw new NoSuchMethodError(str2);
}
try {
Method declaredMethod = cls.getDeclaredMethod(str, clsArr);
declaredMethod.setAccessible(true);
methodCache.put(str2, declaredMethod);
return declaredMethod;
} catch (NoSuchMethodException unused) {
methodCache.put(str2, null);
throw new NoSuchMethodError(str2);
}
}
public static Method findMethodExact(Class<?> cls, String str, Object... objArr) {
return findMethodExact(cls, str, getParameterClasses(cls.getClassLoader(), objArr));
}
public static Method findMethodExact(String str, ClassLoader classLoader, String str2, Object... objArr) {
return findMethodExact(findClass(str, classLoader), str2, getParameterClasses(classLoader, objArr));
}
public static Method findMethodExactIfExists(Class<?> cls, String str, Object... objArr) {
try {
return findMethodExact(cls, str, objArr);
} catch (ClassNotFoundError | NoSuchMethodError unused) {
return null;
}
}
public static Method findMethodExactIfExists(String str, ClassLoader classLoader, String str2, Object... objArr) {
try {
return findMethodExact(str, classLoader, str2, objArr);
} catch (ClassNotFoundError | NoSuchMethodError unused) {
return null;
}
}
public static Method[] findMethodsByExactParameters(Class<?> cls, Class<?> cls2, Class<?>... clsArr) {
boolean z;
LinkedList linkedList = new LinkedList();
Method[] declaredMethods = cls.getDeclaredMethods();
for (Method method : declaredMethods) {
if (cls2 == null || cls2 == method.getReturnType()) {
Class<?>[] parameterTypes = method.getParameterTypes();
if (clsArr.length == parameterTypes.length) {
int i2 = 0;
while (true) {
if (i2 >= clsArr.length) {
z = true;
break;
} else if (clsArr[i2] != parameterTypes[i2]) {
z = false;
break;
} else {
i2++;
}
}
if (z) {
method.setAccessible(true);
linkedList.add(method);
}
}
}
}
return (Method[]) linkedList.toArray(new Method[linkedList.size()]);
}
public static Object getAdditionalInstanceField(Object obj, String str) {
Object obj2;
if (obj == null) {
throw new NullPointerException(jaggu.base.decode("0C040F535410435D4D4316120F0A404651514159145A08"));
} else if (str != null) {
synchronized (additionalFields) {
HashMap<String, Object> hashMap = additionalFields.get(obj);
if (hashMap == null) {
return null;
}
synchronized (hashMap) {
obj2 = hashMap.get(str);
}
return obj2;
}
} else {
throw new NullPointerException(jaggu.base.decode("08031C165A111044185E0D46410751465D410D5B"));
}
}
public static Object getAdditionalStaticField(Class<?> cls, String str) {
return getAdditionalInstanceField(cls, str);
}
public static Object getAdditionalStaticField(Object obj, String str) {
return getAdditionalInstanceField(obj.getClass(), str);
}
public static boolean getBooleanField(Object obj, String str) {
try {
return findField(obj.getClass(), str).getBoolean(obj);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static byte getByteField(Object obj, String str) {
try {
return findField(obj.getClass(), str).getByte(obj);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static char getCharField(Object obj, String str) {
try {
return findField(obj.getClass(), str).getChar(obj);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static Class<?>[] getClassesAsArray(Class<?>... clsArr) {
return clsArr;
}
public static double getDoubleField(Object obj, String str) {
try {
return findField(obj.getClass(), str).getDouble(obj);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static int getFirstParameterIndexByType(Member member, Class<?> cls) {
Class<?>[] parameterTypes = member instanceof Method ? ((Method) member).getParameterTypes() : ((Constructor) member).getParameterTypes();
for (int i2 = 0; i2 < parameterTypes.length; i2++) {
if (parameterTypes[i2] == cls) {
return i2;
}
}
throw new NoSuchFieldError(jaggu.base.decode("2D0945465616025D5D440740410A5246474D115241") + cls + jaggu.base.decode("43000A43590043595610") + member);
}
public static float getFloatField(Object obj, String str) {
try {
return findField(obj.getClass(), str).getFloat(obj);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static int getIntField(Object obj, String str) {
try {
return findField(obj.getClass(), str).getInt(obj);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static long getLongField(Object obj, String str) {
try {
return findField(obj.getClass(), str).getLong(obj);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static String getMD5Sum(String str) throws IOException {
try {
MessageDigest instance = MessageDigest.getInstance(jaggu.base.decode("2E2250"));
FileInputStream fileInputStream = new FileInputStream(str);
byte[] bArr = new byte[FileUtils.BUFFER_SIZE];
while (true) {
int read = fileInputStream.read(bArr);
if (read > 0) {
instance.update(bArr, 0, read);
} else {
fileInputStream.close();
return new BigInteger(1, instance.digest()).toString(16);
}
}
} catch (NoSuchAlgorithmException unused) {
return "";
}
}
public static int getMethodDepth(String str) {
return getMethodDepthCounter(str).get().get();
}
private static ThreadLocal<AtomicInteger> getMethodDepthCounter(String str) {
ThreadLocal<AtomicInteger> threadLocal;
synchronized (sMethodDepth) {
threadLocal = sMethodDepth.get(str);
if (threadLocal == null) {
threadLocal = new ThreadLocal<AtomicInteger>() {
/* class andhook.lib.xposed.XposedHelpers.AnonymousClass1 */
/* access modifiers changed from: protected */
@Override // java.lang.ThreadLocal
public AtomicInteger initialValue() {
return new AtomicInteger();
}
};
sMethodDepth.put(str, threadLocal);
}
}
return threadLocal;
}
public static Object getObjectField(Object obj, String str) {
try {
return findField(obj.getClass(), str).get(obj);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
static Method getOverriddenMethod(Method method) {
int modifiers = method.getModifiers();
if (!Modifier.isStatic(modifiers) && !Modifier.isPrivate(modifiers)) {
String name = method.getName();
Class<?>[] parameterTypes = method.getParameterTypes();
for (Class<? super Object> superclass = method.getDeclaringClass().getSuperclass(); superclass != null; superclass = superclass.getSuperclass()) {
try {
Method declaredMethod = superclass.getDeclaredMethod(name, parameterTypes);
int modifiers2 = declaredMethod.getModifiers();
if (Modifier.isPrivate(modifiers2) || Modifier.isAbstract(modifiers2)) {
return null;
}
return declaredMethod;
} catch (NoSuchMethodException unused) {
}
}
}
return null;
}
static HashSet<Method> getOverriddenMethods(Class<?> cls) {
HashSet<Method> hashSet = new HashSet<>();
for (Method method : cls.getDeclaredMethods()) {
Method overriddenMethod = getOverriddenMethod(method);
if (overriddenMethod != null) {
hashSet.add(overriddenMethod);
}
}
return hashSet;
}
private static Class<?>[] getParameterClasses(ClassLoader classLoader, Object[] objArr) {
Class<?>[] clsArr = null;
for (int length = objArr.length - 1; length >= 0; length--) {
Object obj = objArr[length];
if (obj != null) {
if (!(obj instanceof XC_MethodHook)) {
if (clsArr == null) {
clsArr = new Class[(length + 1)];
}
if (obj instanceof Class) {
clsArr[length] = (Class) obj;
} else if (obj instanceof String) {
clsArr[length] = findClass((String) obj, classLoader);
} else {
throw new ClassNotFoundError(jaggu.base.decode("130717575A0117554A10164B1100140B46471517045F100D5642435053134A4006050C505E010710594342710D044715135B13173242160C5D57"), null);
}
}
} else {
throw new ClassNotFoundError(jaggu.base.decode("130717575A0117554A10164B1100140B464715170F5910455155435C435F55"), null);
}
}
return clsArr == null ? new Class[0] : clsArr;
}
public static int getParameterIndexByType(Member member, Class<?> cls) {
Class<?>[] parameterTypes = member instanceof Method ? ((Method) member).getParameterTypes() : ((Constructor) member).getParameterTypes();
int i2 = 0;
int i3 = -1;
while (true) {
int length = parameterTypes.length;
String decode = jaggu.base.decode("43000A43590043595610");
if (i2 < length) {
if (parameterTypes[i2] == cls) {
if (i3 == -1) {
i3 = i2;
} else {
throw new NoSuchFieldError(jaggu.base.decode("2E09175317100B5156100D5C0445440741550C52155316455C5643464F435C10") + cls + decode + member);
}
}
i2++;
} else if (i3 != -1) {
return i3;
} else {
throw new NoSuchFieldError(jaggu.base.decode("2D0945465616025D5D440740410A5246474D115241") + cls + decode + member);
}
}
}
public static Class<?>[] getParameterTypes(Object... objArr) {
Class<?>[] clsArr = new Class[objArr.length];
for (int i2 = 0; i2 < objArr.length; i2++) {
clsArr[i2] = objArr[i2] != null ? objArr[i2].getClass() : null;
}
return clsArr;
}
private static String getParametersString(Class<?>... clsArr) {
StringBuilder sb = new StringBuilder(jaggu.base.decode("4B"));
boolean z = true;
for (Class<?> cls : clsArr) {
if (z) {
z = false;
} else {
sb.append(jaggu.base.decode("4F"));
}
if (cls != null) {
sb.append(cls.getCanonicalName());
} else {
sb.append(jaggu.base.decode("0D13095A"));
}
}
sb.append(jaggu.base.decode("4A"));
return sb.toString();
}
public static short getShortField(Object obj, String str) {
try {
return findField(obj.getClass(), str).getShort(obj);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static boolean getStaticBooleanField(Class<?> cls, String str) {
try {
return findField(cls, str).getBoolean(null);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static byte getStaticByteField(Class<?> cls, String str) {
try {
return findField(cls, str).getByte(null);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static char getStaticCharField(Class<?> cls, String str) {
try {
return findField(cls, str).getChar(null);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static double getStaticDoubleField(Class<?> cls, String str) {
try {
return findField(cls, str).getDouble(null);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static float getStaticFloatField(Class<?> cls, String str) {
try {
return findField(cls, str).getFloat(null);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static int getStaticIntField(Class<?> cls, String str) {
try {
return findField(cls, str).getInt(null);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static long getStaticLongField(Class<?> cls, String str) {
try {
return findField(cls, str).getLong(null);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static Object getStaticObjectField(Class<?> cls, String str) {
try {
return findField(cls, str).get(null);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static short getStaticShortField(Class<?> cls, String str) {
try {
return findField(cls, str).getShort(null);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static Object getSurroundingThis(Object obj) {
return getObjectField(obj, jaggu.base.decode("170E0C451354"));
}
public static int incrementMethodDepth(String str) {
return getMethodDepthCounter(str).get().incrementAndGet();
}
static byte[] inputStreamToByteArray(InputStream inputStream) throws IOException {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
byte[] bArr = new byte[FileUtils.FileMode.MODE_ISGID];
while (true) {
int read = inputStream.read(bArr);
if (read > 0) {
byteArrayOutputStream.write(bArr, 0, read);
} else {
inputStream.close();
return byteArrayOutputStream.toByteArray();
}
}
}
public static Object newInstance(Class<?> cls, Class<?>[] clsArr, Object... objArr) {
try {
return findConstructorBestMatch(cls, clsArr, objArr).newInstance(objArr);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
} catch (InvocationTargetException e3) {
throw new InvocationTargetError(e3.getCause());
} catch (InstantiationException e4) {
throw new InstantiationError(e4.getMessage());
}
}
public static Object newInstance(Class<?> cls, Object... objArr) {
try {
return findConstructorBestMatch(cls, objArr).newInstance(objArr);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
} catch (InvocationTargetException e3) {
throw new InvocationTargetError(e3.getCause());
} catch (InstantiationException e4) {
throw new InstantiationError(e4.getMessage());
}
}
public static Object removeAdditionalInstanceField(Object obj, String str) {
Object remove;
if (obj == null) {
throw new NullPointerException(jaggu.base.decode("0C040F535410435D4D4316120F0A404651514159145A08"));
} else if (str != null) {
synchronized (additionalFields) {
HashMap<String, Object> hashMap = additionalFields.get(obj);
if (hashMap == null) {
return null;
}
synchronized (hashMap) {
remove = hashMap.remove(str);
}
return remove;
}
} else {
throw new NullPointerException(jaggu.base.decode("08031C165A111044185E0D46410751465D410D5B"));
}
}
public static Object removeAdditionalStaticField(Class<?> cls, String str) {
return removeAdditionalInstanceField(cls, str);
}
public static Object removeAdditionalStaticField(Object obj, String str) {
return removeAdditionalInstanceField(obj.getClass(), str);
}
public static Object setAdditionalInstanceField(Object obj, String str, Object obj2) {
HashMap<String, Object> hashMap;
Object put;
if (obj == null) {
throw new NullPointerException(jaggu.base.decode("0C040F535410435D4D4316120F0A404651514159145A08"));
} else if (str != null) {
synchronized (additionalFields) {
hashMap = additionalFields.get(obj);
if (hashMap == null) {
hashMap = new HashMap<>();
additionalFields.put(obj, hashMap);
}
}
synchronized (hashMap) {
put = hashMap.put(str, obj2);
}
return put;
} else {
throw new NullPointerException(jaggu.base.decode("08031C165A111044185E0D46410751465D410D5B"));
}
}
public static Object setAdditionalStaticField(Class<?> cls, String str, Object obj) {
return setAdditionalInstanceField(cls, str, obj);
}
public static Object setAdditionalStaticField(Object obj, String str, Object obj2) {
return setAdditionalInstanceField(obj.getClass(), str, obj2);
}
public static void setBooleanField(Object obj, String str, boolean z) {
try {
findField(obj.getClass(), str).setBoolean(obj, z);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static void setByteField(Object obj, String str, byte b) {
try {
findField(obj.getClass(), str).setByte(obj, b);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static void setCharField(Object obj, String str, char c) {
try {
findField(obj.getClass(), str).setChar(obj, c);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static void setDoubleField(Object obj, String str, double d) {
try {
findField(obj.getClass(), str).setDouble(obj, d);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static void setFloatField(Object obj, String str, float f) {
try {
findField(obj.getClass(), str).setFloat(obj, f);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static void setIntField(Object obj, String str, int i2) {
try {
findField(obj.getClass(), str).setInt(obj, i2);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static void setLongField(Object obj, String str, long j) {
try {
findField(obj.getClass(), str).setLong(obj, j);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static void setObjectField(Object obj, String str, Object obj2) {
try {
findField(obj.getClass(), str).set(obj, obj2);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static void setShortField(Object obj, String str, short s) {
try {
findField(obj.getClass(), str).setShort(obj, s);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static void setStaticBooleanField(Class<?> cls, String str, boolean z) {
try {
findField(cls, str).setBoolean(null, z);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static void setStaticByteField(Class<?> cls, String str, byte b) {
try {
findField(cls, str).setByte(null, b);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static void setStaticCharField(Class<?> cls, String str, char c) {
try {
findField(cls, str).setChar(null, c);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static void setStaticDoubleField(Class<?> cls, String str, double d) {
try {
findField(cls, str).setDouble(null, d);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static void setStaticFloatField(Class<?> cls, String str, float f) {
try {
findField(cls, str).setFloat(null, f);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static void setStaticIntField(Class<?> cls, String str, int i2) {
try {
findField(cls, str).setInt(null, i2);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static void setStaticLongField(Class<?> cls, String str, long j) {
try {
findField(cls, str).setLong(null, j);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static void setStaticObjectField(Class<?> cls, String str, Object obj) {
try {
findField(cls, str).set(null, obj);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
public static void setStaticShortField(Class<?> cls, String str, short s) {
try {
findField(cls, str).setShort(null, s);
} catch (IllegalAccessException e) {
Log.w(jaggu.base.decode("3B160A4552002B555440074012"), e);
throw new IllegalAccessError(e.getMessage());
} catch (IllegalArgumentException e2) {
throw e2;
}
}
}