Untitled

mail@pastecode.io avatar
unknown
c_cpp
6 months ago
70 kB
15
Indexable
Never
#include "Includes/Logger.h"
#include "Includes/obfuscate.h"
#include "Includes/Utils.h"
#include "ImGui/Call_ImGui.h"
#include "IL2CppSDKGenerator/BasicStructs/Call_BasicStructs.h"
#include "IL2CppSDKGenerator/IL2Cpp/Call_IL2Cpp.h"
#include "Hacks/Hacks.h"
#include "IL2CppSDKGenerator/KittyMemory/MemoryPatch.h"
#include "ImGui/imgui.h"
#include "ImGui/imgui_additional.h"
#include "foxcheats/include/ScanEngine.hpp"
#include "Noctivagous/StrEnc.h"
#include "Noctivagous/json.hpp"
#include "Noctivagous/md5.h"
#include "curl/curl.h"
#include "Oxorany/Oxorany.h"

JavaVM *jvm;
std::string CalcMD5(std::string s);
using json = nlohmann::json;

struct My_Patches {
    MemoryPatch MaxFPS,MaxFPS1, MaxFPS2, MaxFPS3, Aims1, Aims2,Aims3,Aims4,Aims5,Aims6, Wol, Outline1, Outline2,Fastshoot1,Fastshoot2,Fastshoot3,Fastshoot4,Nightmode1,Nightmode2,Fastscope1,Fastscope2,Wireframe,Flashbang,Lb1, Lb2, Lb3, Lb4, Lb5, Lb6, Lb7, Lb8, Lb9,Lb10,Lb11,Lb12,Lb13,Lb14,Lb15,Lb16,Lb17,Lb18,Lb19,Lb20,

Guest1, Guest2,
Lobby1, Lobby2, Lobby3, Lobby4, Lobby5,
Skip1, Skip2,
Mediumaim1, Mediumaim2,
Norwall,
Hit1, Hit2,
Fovcross1, Fovcross2,
Spec1, Spec2, Spec3, Spec4,
Lowbt1, Lowbt2, Lowbt3, Lowbt4,
Dark1, Dark2,
Opti1, Opti2, Opti3, Opti4,
Frame1, Frame2, Frame3, Frame4,
Showfps1, Showfps2
;
} hexPatches;

bool Buff, Krm, Tang, Dlq2, Dlq, Kol, Cb, Nik, Sop, Spec, He1, Off, Buf, Ali, Dl, Pha, Oden, Holger = false;
uintptr_t address = 0;
uintptr_t address2 = 0;
using namespace kFox;
uintptr_t g_il2cpp;
std::string g_Token, g_Auth;
bool bValid = false;

#define CREATE_COLOR(r, g, b, a) new float[4] {(float)r, (float)g, (float)b, (float)a};


#define CREATE_COLOR(r, g, b, a) new float[4] {(float)r, (float)g, (float)b, (float)a};

std::string getClipboard() {
    std::string result;
    JNIEnv *env;

    VM->AttachCurrentThread(&env, NULL);

    auto looperClass = env->FindClass(OBFUSCATE("android/os/Looper"));
    auto prepareMethod = env->GetStaticMethodID(looperClass, OBFUSCATE("prepare"),
                                                OBFUSCATE("()V"));
    env->CallStaticVoidMethod(looperClass, prepareMethod);

    jclass activityThreadClass = env->FindClass(OBFUSCATE("android/app/ActivityThread"));
    jfieldID sCurrentActivityThreadField = env->GetStaticFieldID(activityThreadClass, OBFUSCATE(
            "sCurrentActivityThread"), OBFUSCATE("Landroid/app/ActivityThread;"));
    jobject sCurrentActivityThread = env->GetStaticObjectField(activityThreadClass,
                                                               sCurrentActivityThreadField);

    jfieldID mInitialApplicationField = env->GetFieldID(activityThreadClass,
                                                        OBFUSCATE("mInitialApplication"),
                                                        OBFUSCATE("Landroid/app/Application;"));
    jobject mInitialApplication = env->GetObjectField(sCurrentActivityThread,
                                                      mInitialApplicationField);

    auto contextClass = env->FindClass(OBFUSCATE("android/content/Context"));
    auto getSystemServiceMethod = env->GetMethodID(contextClass, OBFUSCATE("getSystemService"),
                                                   OBFUSCATE(
                                                           "(Ljava/lang/String;)Ljava/lang/Object;"));

    auto str = env->NewStringUTF(OBFUSCATE("clipboard"));
    auto clipboardManager = env->CallObjectMethod(mInitialApplication, getSystemServiceMethod, str);
    env->DeleteLocalRef(str);

    jclass ClipboardManagerClass = env->FindClass(OBFUSCATE("android/content/ClipboardManager"));
    auto getText = env->GetMethodID(ClipboardManagerClass, OBFUSCATE("getText"),
                                    OBFUSCATE("()Ljava/lang/CharSequence;"));

    jclass CharSequenceClass = env->FindClass(OBFUSCATE("java/lang/CharSequence"));
    auto toStringMethod = env->GetMethodID(CharSequenceClass, OBFUSCATE("toString"),
                                           OBFUSCATE("()Ljava/lang/String;"));

    auto text = env->CallObjectMethod(clipboardManager, getText);
    if (text) {
        str = (jstring) env->CallObjectMethod(text, toStringMethod);
        result = env->GetStringUTFChars(str, 0);
        env->DeleteLocalRef(str);
        env->DeleteLocalRef(text);
    }

    env->DeleteLocalRef(CharSequenceClass);
    env->DeleteLocalRef(ClipboardManagerClass);
    env->DeleteLocalRef(clipboardManager);
    env->DeleteLocalRef(contextClass);
    env->DeleteLocalRef(mInitialApplication);
    env->DeleteLocalRef(activityThreadClass);
    VM->DetachCurrentThread();
    return result.c_str();
}


//=================================================================\\

struct MemoryStruct {
    char *memory;
    size_t size;
};

static size_t WriteMemoryCallback(void *contents, size_t size, size_t nmemb, void *userp) {
    size_t realsize = size * nmemb;
    auto *mem = (struct MemoryStruct *) userp;

    mem->memory = (char *) realloc(mem->memory, mem->size + realsize + 1);
    if (mem->memory == nullptr) {
        return 0;
    }

    memcpy(&(mem->memory[mem->size]), contents, realsize);
    mem->size += realsize;
    mem->memory[mem->size] = 0;

    return realsize;
}

const char *GetAndroidID(JNIEnv *env, jobject context) {
        jclass contextClass = env->FindClass(/*android/content/Context*/ StrEnc("`L+&0^[S+-:J^$,r9q92(as", "\x01\x22\x4F\x54\x5F\x37\x3F\x7C\x48\x42\x54\x3E\x3B\x4A\x58\x5D\x7A\x1E\x57\x46\x4D\x19\x07", 23).c_str());
        jmethodID getContentResolverMethod = env->GetMethodID(contextClass, /*getContentResolver*/ StrEnc("E8X\\7r7ys_Q%JS+L+~", "\x22\x5D\x2C\x1F\x58\x1C\x43\x1C\x1D\x2B\x03\x40\x39\x3C\x47\x3A\x4E\x0C", 18).c_str(), /*()Landroid/content/ContentResolver;*/ StrEnc("8^QKmj< }5D:9q7f.BXkef]A*GYLNg}B!/L", "\x10\x77\x1D\x2A\x03\x0E\x4E\x4F\x14\x51\x6B\x59\x56\x1F\x43\x03\x40\x36\x77\x28\x0A\x08\x29\x24\x44\x33\x0B\x29\x3D\x08\x11\x34\x44\x5D\x77", 35).c_str());
        jclass settingSecureClass = env->FindClass(/*android/provider/Settings$Secure*/ StrEnc("T1yw^BCF^af&dB_@Raf}\\FS,zT~L(3Z\"", "\x35\x5F\x1D\x05\x31\x2B\x27\x69\x2E\x13\x09\x50\x0D\x26\x3A\x32\x7D\x32\x03\x09\x28\x2F\x3D\x4B\x09\x70\x2D\x29\x4B\x46\x28\x47", 32).c_str());
        jmethodID getStringMethod = env->GetStaticMethodID(settingSecureClass, /*getString*/ StrEnc("e<F*J5c0Y", "\x02\x59\x32\x79\x3E\x47\x0A\x5E\x3E", 9).c_str(), /*(Landroid/content/ContentResolver;Ljava/lang/String;)Ljava/lang/String;*/ StrEnc("$6*%R*!XO\"m18o,0S!*`uI$IW)l_/_knSdlRiO1T`2sH|Ouy__^}%Y)JsQ:-\"(2_^-$i{?H", "\x0C\x7A\x4B\x4B\x36\x58\x4E\x31\x2B\x0D\x0E\x5E\x56\x1B\x49\x5E\x27\x0E\x69\x0F\x1B\x3D\x41\x27\x23\x7B\x09\x2C\x40\x33\x1D\x0B\x21\x5F\x20\x38\x08\x39\x50\x7B\x0C\x53\x1D\x2F\x53\x1C\x01\x0B\x36\x31\x39\x46\x0C\x15\x43\x2B\x05\x30\x15\x41\x43\x46\x55\x70\x0D\x59\x56\x00\x15\x58\x73", 71).c_str());

        auto obj = env->CallObjectMethod(context, getContentResolverMethod);
        auto str = (jstring) env->CallStaticObjectMethod(settingSecureClass, getStringMethod, obj, env->NewStringUTF(/*android_id*/ StrEnc("ujHO)8OfOE", "\x14\x04\x2C\x3D\x46\x51\x2B\x39\x26\x21", 10).c_str()));
        return env->GetStringUTFChars(str, 0);
    }

    const char *GetDeviceModel(JNIEnv *env) {
        jclass buildClass = env->FindClass(/*android/os/Build*/ StrEnc("m5I{GKGWBP-VOxkA", "\x0C\x5B\x2D\x09\x28\x22\x23\x78\x2D\x23\x02\x14\x3A\x11\x07\x25", 16).c_str());
        jfieldID modelId = env->GetStaticFieldID(buildClass, /*MODEL*/ StrEnc("|}[q:", "\x31\x32\x1F\x34\x76", 5).c_str(), /*Ljava/lang/String;*/ StrEnc(".D:C:ETZ1O-Ib&^h.Y", "\x62\x2E\x5B\x35\x5B\x6A\x38\x3B\x5F\x28\x02\x1A\x16\x54\x37\x06\x49\x62", 18).c_str());

        auto str = (jstring) env->GetStaticObjectField(buildClass, modelId);
        return env->GetStringUTFChars(str, 0);
    }

    const char *GetDeviceBrand(JNIEnv *env) {
        jclass buildClass = env->FindClass(/*android/os/Build*/ StrEnc("0iW=2^>0zTRB!B90", "\x51\x07\x33\x4F\x5D\x37\x5A\x1F\x15\x27\x7D\x00\x54\x2B\x55\x54", 16).c_str());
        jfieldID modelId = env->GetStaticFieldID(buildClass, /*BRAND*/ StrEnc("@{[FP", "\x02\x29\x1A\x08\x14", 5).c_str(), /*Ljava/lang/String;*/ StrEnc(".D:C:ETZ1O-Ib&^h.Y", "\x62\x2E\x5B\x35\x5B\x6A\x38\x3B\x5F\x28\x02\x1A\x16\x54\x37\x06\x49\x62", 18).c_str());

        auto str = (jstring) env->GetStaticObjectField(buildClass, modelId);
        return env->GetStringUTFChars(str, 0);
    }

    const char *GetPackageName(JNIEnv *env, jobject context) {
        jclass contextClass = env->FindClass(/*android/content/Context*/ StrEnc("`L+&0^[S+-:J^$,r9q92(as", "\x01\x22\x4F\x54\x5F\x37\x3F\x7C\x48\x42\x54\x3E\x3B\x4A\x58\x5D\x7A\x1E\x57\x46\x4D\x19\x07", 23).c_str());
        jmethodID getPackageNameId = env->GetMethodID(contextClass, /*getPackageName*/ StrEnc("YN4DaP)!{wRGN}", "\x3E\x2B\x40\x14\x00\x33\x42\x40\x1C\x12\x1C\x26\x23\x18", 14).c_str(), /*()Ljava/lang/String;*/ StrEnc("VnpibEspM(b]<s#[9cQD", "\x7E\x47\x3C\x03\x03\x33\x12\x5F\x21\x49\x0C\x3A\x13\x20\x57\x29\x50\x0D\x36\x7F", 20).c_str());

        auto str = (jstring) env->CallObjectMethod(context, getPackageNameId);
        return env->GetStringUTFChars(str, 0);
    }

    const char *GetDeviceUniqueIdentifier(JNIEnv *env, const char *uuid) {
        jclass uuidClass = env->FindClass(/*java/util/UUID*/ StrEnc("B/TxJ=3BZ_]SFx", "\x28\x4E\x22\x19\x65\x48\x47\x2B\x36\x70\x08\x06\x0F\x3C", 14).c_str());

        auto len = strlen(uuid);

        jbyteArray myJByteArray = env->NewByteArray(len);
        env->SetByteArrayRegion(myJByteArray, 0, len, (jbyte *) uuid);

        jmethodID nameUUIDFromBytesMethod = env->GetStaticMethodID(uuidClass, /*nameUUIDFromBytes*/ StrEnc("P6LV|'0#A+zQmoat,", "\x3E\x57\x21\x33\x29\x72\x79\x67\x07\x59\x15\x3C\x2F\x16\x15\x11\x5F", 17).c_str(), /*([B)Ljava/util/UUID;*/ StrEnc("sW[\"Q[W3,7@H.vT0) xB", "\x5B\x0C\x19\x0B\x1D\x31\x36\x45\x4D\x18\x35\x3C\x47\x1A\x7B\x65\x7C\x69\x3C\x79", 20).c_str());
        jmethodID toStringMethod = env->GetMethodID(uuidClass, /*toString*/ StrEnc("2~5292eW", "\x46\x11\x66\x46\x4B\x5B\x0B\x30", 8).c_str(), /*()Ljava/lang/String;*/ StrEnc("P$BMc' #j?<:myTh_*h0", "\x78\x0D\x0E\x27\x02\x51\x41\x0C\x06\x5E\x52\x5D\x42\x2A\x20\x1A\x36\x44\x0F\x0B", 20).c_str());

        auto obj = env->CallStaticObjectMethod(uuidClass, nameUUIDFromBytesMethod, myJByteArray);
        auto str = (jstring) env->CallObjectMethod(obj, toStringMethod);
        return env->GetStringUTFChars(str, 0);
    }




//========================= MAIN LOGIN =======================\\

std::string Login(const char *user_key) {
    JNIEnv *env;
    VM->AttachCurrentThread(&env, nullptr);
    std::string hwid = user_key;
    object = getGlobalContext(env);
    hwid += GetAndroidID(env, object);
    hwid += GetDeviceModel(env);
    hwid += GetDeviceBrand(env);
    std::string UUID = GetDeviceUniqueIdentifier(env, hwid.c_str());
    VM->DetachCurrentThread();
    std::string errMsg;

    struct MemoryStruct chunk{};
    chunk.memory = (char *) malloc(1);
    chunk.size = 0;

   CURL *curl;
    CURLcode res;
    curl = curl_easy_init();

    if (curl) {
        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, /*POST*/ StrEnc(",IL=", "\x7C\x06\x1F\x69", 4).c_str());
  std::string hikbhii = OBFUSCATE("https://dcibpanel.000webhostapp.com/public/connect");

  curl_easy_setopt(curl, CURLOPT_URL, hikbhii.c_str());
  curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
  curl_easy_setopt(curl, CURLOPT_DEFAULT_PROTOCOL, StrEnc("!mLBO", "\x4 9\x19\x38\x32\x3C", 5).c_str());
  struct curl_slist *headers = NULL;
  headers = curl_slist_append(headers, StrEnc("@;Ls\\(KP4Qrop`b#d3094/r1cf<c<=H)AiiBG6i|Ta66s2[", "\x03\x54\x22\x07\x39\x46\x3F\x7D\x60\x28\x02\x0A\x4A\x40\x03\x53\x14\x5F\x59\x5A\x55\x5B\x1B\x5E\x0D\x49\x44\x4E\x4B\x4A\x3F\x04\x27\x06\x1B\x2F\x6A\x43\x1B\x10\x31\x0F\x55\x59\x17\x57\x3F", 47).c_str());
  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
  char data[4096];
        sprintf(data, OBFUSCATE("game=CODM&user_key=%s&serial=%s"), user_key, UUID.c_str());
        curl_easy_setopt(curl, CURLOPT_POST, 1);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *) &chunk);
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 2);
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYSTATUS, 0);

        res = curl_easy_perform(curl);
        if (res == CURLE_OK) {
            try {
                nlohmann::json result = nlohmann::json::parse(chunk.memory);
                auto STATUS = std::string{oxorany("status")};
                if (result[STATUS] == true) {
                    auto DATA = std::string{oxorany("data")};
                    auto TOKEN = std::string{oxorany("token")};
                    auto RNG = std::string{oxorany("rng")};	
                    std::string token = result[DATA][TOKEN].get<std::string>();
                    time_t rng = result[DATA][RNG].get<time_t>();			
                    if (rng + 30 > time(0)) {
                        std::string auth = OBFUSCATE("CODM");
                        auth += "-";
                        auth += user_key;
                        auth += "-";
                        auth += UUID;
                        auth += "-";
                        auth += /*Vm8Lk7Uj2JmsjCPVPVjrLa7zgfx3uz9E*/ StrEnc("ZD$_K NtaM8Fu=n0fFyO;!Ae<H)*Gy4%", "\x0C\x29\x1C\x13\x20\x17\x1B\x1E\x53\x07\x55\x35\x1F\x7E\x3E\x66\x36\x10\x13\x3D\x77\x40\x76\x1F\x5B\x2E\x51\x19\x32\x03\x0D\x60", 32).c_str();;
                        std::string outputAuth = md5(auth);

                        g_Token = token;
                        g_Auth = outputAuth;
                        bValid = g_Token == g_Auth;

                        if (bValid) {

                        }
                    }
                } else {
                    auto REASON = std::string{oxorany("reason")};
                    errMsg = result[REASON].get<std::string>();
                }
            } catch (nlohmann::json::exception &e) {
                errMsg = "{";
                errMsg += e.what();
                errMsg += "}\n{";
                errMsg += chunk.memory;
                errMsg += "}";
            }
        } else {
            errMsg = curl_easy_strerror(res);
        }
    }
    curl_easy_cleanup(curl);
    //VM->DetachCurrentThread();

    return bValid ? OBFUSCATE("OK") : errMsg;
}



EGLBoolean (*old_eglSwapBuffers)(EGLDisplay dpy, EGLSurface surface);
EGLBoolean hook_eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) {
	if (!Config.ImGuiMenu.g_Initialized) {
		IMGUI_CHECKVERSION();
		ImGui::CreateContext();
                ImGuiStyle *style = &ImGui::GetStyle();
        
		ImGuiIO& io = ImGui::GetIO();
		
		     style->WindowPadding = ImVec2(9,8);
            style->WindowRounding = 4.4f;
            style->FramePadding = ImVec2(4, 4);
            style->FrameRounding = 3.0f;
		    style->FrameBorderSize = 0.0f;
		    style->WindowBorderSize = 1.0f;
			style->TabRounding = 2.5f;
			style->GrabRounding = 1.5f;
	
		

			
        style->WindowTitleAlign = ImVec2(0.5, 0.5);
		style->ButtonTextAlign = ImVec2(0.5,0.5);
		style->Colors[ImGuiCol_Text]                  = ImColor(0, 0, 0, 255);
	    style->Colors[ImGuiCol_WindowBg]              = ImVec4(255, 255, 255, 1.00f);
	    style->Colors[ImGuiCol_Border]                = ImColor(144, 145, 147, 255);
        style->Colors[ImGuiCol_FrameBg]               = ImColor(195, 206, 210, 255);
		style->Colors[ImGuiCol_FrameBgActive]               = ImColor(242, 167, 144, 255);
		style->Colors[ImGuiCol_FrameBgHovered]               = ImColor(242, 167, 144, 255);
	    style->Colors[ImGuiCol_PopupBg]               = ImColor(23, 101, 111, 255);

     	style->Colors[ImGuiCol_Tab] = ImColor(101, 136, 142, 120);
	    style->Colors[ImGuiCol_TabActive] = ImColor(101, 136, 142, 120);
	    style->Colors[ImGuiCol_TabHovered] = ImColor(101, 136, 142, 120);
		
		style->Colors[ImGuiCol_Button]                   = ImColor(252, 210, 89, 255);
		style->Colors[ImGuiCol_ButtonActive]             = ImColor(131, 215, 252, 255);
		style->Colors[ImGuiCol_ButtonHovered]            = ImColor(252, 210, 89, 255);
		
		style->Colors[ImGuiCol_ScrollbarBg]           = ImColor(219, 228, 233, 255);
        style->Colors[ImGuiCol_ScrollbarGrab]         = ImColor(183, 209, 226, 255);
        style->Colors[ImGuiCol_ScrollbarGrabHovered]  = ImColor(183, 209, 226, 255);
        style->Colors[ImGuiCol_ScrollbarGrabActive]   = ImColor(183, 209, 226, 255);
		
		style->Colors[ImGuiCol_Header]                = ImColor(181, 208, 219, 255);
        style->Colors[ImGuiCol_HeaderActive]          = ImColor(201, 227, 240, 255);
        style->Colors[ImGuiCol_HeaderHovered]         = ImColor(201, 227, 240, 255);

        style->Colors[ImGuiCol_TitleBg]               = ImVec4(0, 153, 255, 1.00f);
        style->Colors[ImGuiCol_TitleBgActive]         = ImVec4(0, 153, 255, 1.00f);
        style->Colors[ImGuiCol_TitleBgCollapsed]      = ImColor(131, 215, 252, 60);
	    style->Colors[ImGuiCol_CheckMark]             = ImColor(144, 145, 147, 255);
		
        /*style->ScaleAllSizes(std::max(1.0f, density / 210.0f));*/
        style->ScrollbarSize /= 1;
        
        ImGui_ImplOpenGL3_Init("#version 300 es");
        
        //ImFontConfig cfg;
        //cfg.SizePixels = ((float) get_density() / 20.0f);
        static const ImWchar ranges[] = { 
        0x0020, 0x00FF, 
        0x4E00, 0x9FBF,
        0x4E00, 0x62FF, 
        0x6300, 0x77FF, 
        0x7800, 0x8CFF, 
        0x8D00, 0x9FFF,
        0x0100, 0x017F,
        0x2E00, 0x2E7F,      
        0x3040, 0x309F,
        0x3000, 0x30FF,
        0x3300, 0x33FF,
        0x0180, 0x024F,
        0x31F0, 0x31FF,
        0xFF00, 0xFFEF,
        0x2600, 0x26FF,
        0xFFFD, 0xFFFD,
        0xFFF0, 0xFFFF,
        0x3041, 0x3096, 
        0x30A0, 0x30FF, 
        0x3400, 0x4DB5, 
        0x4E00, 0x9FCB, 
        0xF900, 0xFA6A,
        0x2E80, 0x2FD5, 
        0xFF5F, 0xFF9F, 
        0x3000, 0x303F,
        0x3220, 0x3243,
        0x3280, 0x337F,
        0xFF01, 0xFF5E,
        0x3400, 0x4DBF,
        0x2010, 0x205E,
        0x0E00, 0x0E7F,
        0
        }; 
    ImFontConfig font_cfg;
        io.Fonts->AddFontFromMemoryCompressedTTF(GoogleSans_compressed_data, GoogleSans_compressed_size, 24.0f/*(float) get_dpi() / 14.0f*/, &font_cfg);
        ImGui::GetStyle().ScaleAllSizes(3.0f);
        memset(&Config, 0, sizeof(sConfig));
        Config.ColorsESP.PovC = CREATE_COLOR(255,255,255,255);
        Config.ColorsESP.LineC = CREATE_COLOR(0, 255, 0, 0);
        Config.ColorsESP.BoxC = CREATE_COLOR(255, 255, 255, 255);
        Config.ColorsESP.NameC = CREATE_COLOR(255, 255, 255, 100);
        Config.ColorsESP.DistanceC = CREATE_COLOR(255, 225, 0, 255);
        Config.ColorsESP.HealthC = CREATE_COLOR(255, 0, 255, 255);
        Config.ImGuiMenu.g_Initialized = true;
    }
    
    ImGuiIO* io = &ImGui::GetIO();
    ImGui_ImplOpenGL3_NewFrame();
    ImGui_ImplAndroid_NewFrame(get_width(), get_height());
    ImGui::NewFrame();
    io->KeysDown[io->KeyMap[ImGuiKey_UpArrow]] = false;
    io->KeysDown[io->KeyMap[ImGuiKey_DownArrow]] = false;
    io->KeysDown[io->KeyMap[ImGuiKey_LeftArrow]] = false;
    io->KeysDown[io->KeyMap[ImGuiKey_RightArrow]] = false;
    io->KeysDown[io->KeyMap[ImGuiKey_Tab]] = false;
    io->KeysDown[io->KeyMap[ImGuiKey_Enter]] = false;
    io->KeysDown[io->KeyMap[ImGuiKey_Backspace]] = false;
    io->KeysDown[io->KeyMap[ImGuiKey_PageUp]] = false;
    io->KeysDown[io->KeyMap[ImGuiKey_PageDown]] = false;
    io->KeysDown[io->KeyMap[ImGuiKey_Escape]] = false;
    io->KeysDown[io->KeyMap[ImGuiKey_Delete]] = false;
    io->KeysDown[io->KeyMap[ImGuiKey_Home]] = false;
    io->KeysDown[io->KeyMap[ImGuiKey_End]] = false;
    io->KeysDown[io->KeyMap[ImGuiKey_Insert]] = false;
    ImGui::SetNextWindowSize(ImVec2((float) get_width() * 0.45f, (float) get_height() * 0.82f), ImGuiCond_Once);
    DrawESP(ImGui::GetBackgroundDrawList(), get_width(), get_height(),get_density());
	
    char fpsText[32];
snprintf(fpsText, sizeof(fpsText), "~ %.2f FPS", fps);
	
 if (ImGui::Begin(OBFUSCATE(" HARRIS×XENOX VIP GARENA ")), 0, ImGuiWindowFlags_AlwaysAutoResize) {        
        static bool isLogin = false, logginIn = false;
        static std::string err;
		
        if (!isLogin) {
            ImGui::Text(OBFUSCATE(" Please Login First! (Copy Key to Clipboard)"));
                                
            ImGui::PushItemWidth(-1);
            static char s[150];
            ImGui::InputText("##key", s, sizeof s);
            
            ImGui::PopItemWidth();
            ImGui::PushItemWidth(-1);
            if (ImGui::Button(OBFUSCATE(" Paste Key  "), ImVec2(ImGui::GetWindowContentRegionWidth(), 0))) {
                auto key = getClipboard();
                strncpy(s, key.c_str(), sizeof s);

            }
            ImGui::PopItemWidth();
            
            ImGui::PushItemWidth(-1);
            
            if (ImGui::Button(OBFUSCATE("Login"), ImVec2(ImGui::GetWindowContentRegionWidth(), 0))) {
                err = Login(s);
                if (err == "OK") {
                    isLogin = bValid && g_Auth == g_Token;
                }
            }
            ImGui::PopItemWidth();
            
            if (!err.empty() && err != std::string(OBFUSCATE("OK"))) {
                ImGui::Text(OBFUSCATE("Error: %s"), err.c_str());
            }
            ImGui::PopItemWidth();
			
            } else {	  
	           
			
			{
		 
     static int tab = 1;	
	 ImGui::Columns(2);
        ImGui::SetColumnOffset(1, 1100);
        {
			
	ImGuiIO io = ImGui::GetIO();
	            ImGui::BeginGroupPanel(OBFUSCATE("ImGui Internal Fps"), ImVec2(0.0f, 0.0f));
    ImGui::Spacing();
    ImGui::Text(" FPS - %.1f", 1000.0f / ImGui::GetIO().Framerate);
    ImGui::Spacing();
    ImGui::EndGroupPanel();
			
			  if (ImGui::CollapsingHeader(" ESP MENU")) { 
	
	ImGui::TableNextColumn();
		ImGui::Spacing();
        ImGui::BeginGroupPanel("ESP MENU ", ImVec2(10, 20));
        ImGui::Spacing();
        ImGui::Checkbox("ESP Enable", &Config.ESPMenu.ESP);  
        ImGui::Checkbox("ESP Box", &Config.ESPMenu.isPlayerBox);
        ImGui::Checkbox("ESP Line", &Config.ESPMenu.isPlayerLine);
        ImGui::Checkbox("ESP Alert", &Config.ESPMenu.Count);
        ImGui::Checkbox("ESP Name", &Config.ESPMenu.isPlayerName);     
	    ImGui::Checkbox("ESP Distance", &Config.ESPMenu.isPlayerDist);
        ImGui::Checkbox("ESP Health", &Config.ESPMenu.isPlayerHealth);              
        ImGui::Text("Box Style :");
        static const char *FT_BoxNig[] = {"Box", "Centred"};
        ImGui::Combo("##Box", (int *) &Config.ESPMenu.Boxer, FT_BoxNig, 2, -1);
        ImGui::Text("Health Location :");
        static const char *FT_Health[] = {"Top", "Side"};
        ImGui::Combo("##Health", (int *) &Config.ESPMenu.Heal, FT_Health, 2, -1); 
		
        ImGui::Spacing();
        ImGui::EndGroupPanel();              
        ImGui::EndTabItem();            
  
    }
		if (ImGui::CollapsingHeader(" AIM MENU ")) {   
		
		ImGui::TableNextColumn();
		ImGui::Spacing();
		            ImGui::Spacing();
	                ImGui::BeginGroupPanel("Adjustable Menu", ImVec2(0.0f, 0.0f));
                    ImGui::Checkbox("Aim Assist Rifle", &Config.ExtraMenu.AimAssist);
                    ImGui::SliderFloat("Set Rifle", &Config.ExtraMenu.SizeAim, 0.0f, 300.0f);
                    ImGui::Checkbox("Aim Assist Sniper", &Config.ExtraMenu.AimAssist2);
                    ImGui::SliderFloat("Set Sniper", &Config.ExtraMenu.SizeAim2, 0.0f, 300.0f);
                    ImGui::EndGroupPanel();
                }
		
	if (ImGui::CollapsingHeader(" MEMORY HACKS ")) { 
	
	ImGui::TableNextColumn();
		ImGui::Spacing();
                    ImGui::Spacing();
                    ImGui::BeginGroupPanel("MEMORY 1", ImVec2(0.0f, 0.0f));
					ImGui::Checkbox("Buff Damage", &Config.ExtraMenu.Buff);
					ImGui::Checkbox("Wallhack", &Config.ExtraMenu.Wallhack);
                    ImGui::Checkbox("Outline", &Config.ExtraMenu.Outline);
                    ImGui::Checkbox("No Reload", &Config.ExtraMenu.Reload);
					ImGui::EndGroupPanel();
                    
                    ImGui::SameLine();
                    ImGui::BeginGroupPanel("MEMORY 3 ", ImVec2(0.0f, 0.0f));
                    
                    ImGui::Checkbox("No Recoil", &Config.ExtraMenu.Recoil);
                    ImGui::Checkbox("No Spread", &Config.ExtraMenu.Spread);
                    ImGui::Checkbox("Fast Scope", &Config.ExtraMenu.Scope);
                    ImGui::Checkbox("Fast Switch", &Config.ExtraMenu.Switch);
                    ImGui::Checkbox("Fire Rate", &Config.ExtraMenu.Sniper);
                    ImGui::Spacing();
                    ImGui::Checkbox("Aim Smooth", &Config.ExtraMenu.Somo);
					ImGui::Spacing();
                    ImGui::EndGroupPanel();
					
					ImGui::SameLine();
					ImGui::BeginGroupPanel("MEMORY 2", ImVec2(0.0f, 0.0f));
					
					ImGui::Checkbox("Small Crosshair", &Config.ExtraMenu.Smallcross);
					ImGui::Checkbox("Fast Swimming", &Config.ExtraMenu.Swim);
					ImGui::Checkbox("No Parachute", &Config.ExtraMenu.Parachute);
					ImGui::Checkbox("Speed Hack", &Config.ExtraMenu.Speed);
                    ImGui::Text("Set Speed : ");
                    ImGui::SliderFloat("Set Speed", &Config.ExtraMenu.SizeSpeed, 0, 300);
			        ImGui::Checkbox(OBFUSCATE("Long Slide"), &Config.ExtraMenu.Slide);
                    ImGui::SliderFloat(OBFUSCATE("Set Slide"), &Config.ExtraMenu.SizeSlide, 0.0f, 3000.0f);
		            ImGui::EndGroupPanel();
                    
                    
               }  
	
	if (ImGui::CollapsingHeader(" SKIN HACKS ")) { 
	
	ImGui::TableNextColumn();
		ImGui::Spacing();
                     ImGui::BeginGroupPanel("Mythic Skins", ImVec2(0.0f, 0.0f));
                    ImGui::Spacing();
                    ImGui::Checkbox("Dlq - LotusFlames", &Config.ExtraMenu.Dlq2);
                    ImGui::Checkbox("Krig6 - IceDrake", &Config.ExtraMenu.Dlq);
                    ImGui::Checkbox("Cbr4 - Amoeba", &Config.ExtraMenu.Cb);
                    ImGui::Checkbox("Kilo141 - Demonsong", &Config.ExtraMenu.Kol);
                    ImGui::Checkbox("M13 - Morning Star", &Config.ExtraMenu.Mol);
			        ImGui::Checkbox("Oden - Divine Smite", &Config.ExtraMenu.Oden);
                    ImGui::Checkbox("Holger26 - Dark Frontier", &Config.ExtraMenu.Holger);
                    ImGui::Spacing();
                    ImGui::EndGroupPanel();
					
                    ImGui::SameLine();
                    ImGui::BeginGroupPanel("Legendary Skins", ImVec2(0.0f, 0.0f));
                    ImGui::Spacing();
                    ImGui::Checkbox("Tang Knife", &Config.ExtraMenu.Tang);
                    ImGui::Checkbox("Krm - GloriusBlade", &Config.ExtraMenu.Krm);
                    ImGui::Checkbox("Dlq33 - Holidays", &Config.ExtraMenu.Dlq22);
                    ImGui::Spacing();
                    ImGui::EndGroupPanel();
					
                    ImGui::BeginGroupPanel("Character Skins", ImVec2(0.0f, 0.0f));
                    ImGui::Spacing();
                    ImGui::Checkbox("Spectre T2 - Violet", &Config.ExtraMenu.Spec);
                    ImGui::Checkbox("Nikto - Darkside", &Config.ExtraMenu.Nik);
                    ImGui::Checkbox("Sophia - Errantknight", &Config.ExtraMenu.Sop);
                    ImGui::Checkbox("Alias - Roboticist", &Config.ExtraMenu.Ali);
                    ImGui::Checkbox("Phantom - Orisis", &Config.ExtraMenu.Pan);
                    ImGui::Spacing();
                    ImGui::EndGroupPanel();
                    ImGui::EndTabItem();            
                }
}

                                                
if (Config.ExtraMenu.Clear) {
hexPatches.Guest1.Modify();    
hexPatches.Guest2.Modify();    
} else {
hexPatches.Guest1.Restore();   
hexPatches.Guest2.Restore();
}
if (Config.ExtraMenu.Night) {
hexPatches.Dark1.Modify();    
hexPatches.Dark2.Modify();    
} else {
hexPatches.Dark1.Restore();   
hexPatches.Dark2.Restore();
}

if (Config.ExtraMenu.Wallhack) {
hexPatches.Norwall.Modify();    
} else {  
hexPatches.Norwall.Restore();
}
if (Config.ExtraMenu.Hitmark) {
hexPatches.Hit1.Modify();
hexPatches.Hit2.Modify();
} else {
hexPatches.Hit1.Restore();
hexPatches.Hit2.Restore();
}
if (Config.ExtraMenu.Fovcross) {
hexPatches.Fovcross1.Modify();
hexPatches.Fovcross2.Modify();
} else {
hexPatches.Fovcross1.Restore();
hexPatches.Fovcross2.Restore();
}
if (Config.ExtraMenu.Somo) {
hexPatches.Mediumaim1.Modify();    
hexPatches.Mediumaim2.Modify();    
} else {
hexPatches.Mediumaim1.Restore();   
hexPatches.Mediumaim2.Restore();
}
if (Config.ExtraMenu.Spectator) {
hexPatches.Spec1.Modify();
hexPatches.Spec2.Modify();
hexPatches.Spec3.Modify();
hexPatches.Spec4.Modify();
} else {
hexPatches.Spec1.Restore();
hexPatches.Spec2.Restore();
hexPatches.Spec3.Restore();
hexPatches.Spec4.Restore();
}
if (Config.ExtraMenu.Lowbt) {
hexPatches.Lowbt1.Modify();
hexPatches.Lowbt2.Modify();
hexPatches.Lowbt3.Modify();
hexPatches.Lowbt4.Modify();
} else {
hexPatches.Lowbt1.Restore();
hexPatches.Lowbt2.Restore();
hexPatches.Lowbt3.Restore();
hexPatches.Lowbt4.Restore();
}
if (Config.ExtraMenu.Night) {
hexPatches.Dark1.Modify();    
hexPatches.Dark2.Modify();    
} else {
hexPatches.Dark1.Restore();   
hexPatches.Dark2.Restore();
}
if (Config.ExtraMenu.Tutorial) {
hexPatches.Skip1.Modify();    
hexPatches.Skip2.Modify();    
} else {
hexPatches.Skip1.Restore();   
hexPatches.Skip2.Restore();
}
if (Config.ExtraMenu.Ultra) {
hexPatches.Frame1.Modify();
hexPatches.Frame2.Modify();
hexPatches.Frame3.Modify();
hexPatches.Frame4.Modify();
} else {
hexPatches.Frame1.Restore();
hexPatches.Frame2.Restore();
hexPatches.Frame3.Restore();
hexPatches.Frame4.Restore();
}
if (Config.ExtraMenu.Show) {
hexPatches.Showfps1.Modify();    
hexPatches.Showfps2.Modify();    
} else {
hexPatches.Showfps1.Restore();   
hexPatches.Showfps2.Restore();
}
}
}
}

    
auto Input_get_touchCount = (int (*) ()) (Class_Input__get_touchCount);
	 if (Input_get_touchCount() > 0) {
		auto Input_GetTouch = (Touch (*)(uintptr_t, int)) (Class_Input__GetTouch);
		auto Input_get_mousePosition = (Vector3 (*)(uintptr_t)) (Class_Input__get_mousePosition);
		switch (Input_GetTouch(Config.ImGuiMenu.thiz, 0).m_Phase) {
			case TouchPhase::Began:
			case TouchPhase::Stationary:
				io->MouseDown[0] = true;
				io->MousePos = ImVec2(Input_get_mousePosition(Config.ImGuiMenu.thiz).x, get_height() - Input_get_mousePosition(Config.ImGuiMenu.thiz).y);
				break;
			case TouchPhase::Ended:
			case TouchPhase::Canceled:
				io->MouseDown[0] = false;
				Config.ImGuiMenu.clearMousePos = true;
				break;
			case TouchPhase::Moved:
				io->MousePos = ImVec2(Input_get_mousePosition(Config.ImGuiMenu.thiz).x, get_height() - Input_get_mousePosition(Config.ImGuiMenu.thiz).y);
			break;
		    default:
			break;
		}
	}
	
    ImGui::EndFrame();
    ImGui::Render();
	ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
    return old_eglSwapBuffers(dpy, surface);
}

void* SuperThread(void*) {
    while (true) {
        auto t1 = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
		if (Config.ExtraMenu.Dlq) {
            kFox::SetSearchRange(RegionType::ANONYMOUS);
            kFox::MemorySearch( "10126001", Type::TYPE_DWORD);
            kFox::MemoryOffset( "1057803469", 16, Type::TYPE_DWORD);
            kFox::MemoryWrite( "74474", -12, Type::TYPE_DWORD);
            kFox::MemorySearch( "10126001", Type::TYPE_DWORD);
            kFox::MemoryOffset( "1880000001", 24, Type::TYPE_DWORD);
            kFox::MemoryWrite( "16843009", -12, Type::TYPE_DWORD);
            kFox::MemoryWrite( "1", -8, Type::TYPE_DWORD);
            kFox::MemoryWrite( "5", 8, Type::TYPE_DWORD);
            kFox::MemoryWrite( "400010", 52, Type::TYPE_DWORD);
            kFox::MemoryWrite( "200157", 56, Type::TYPE_DWORD);
            kFox::MemoryWrite( "500063", 60, Type::TYPE_DWORD);
            kFox::MemoryWrite( "3", 64, Type::TYPE_DWORD);
            kFox::MemorySearch( "10126001", Type::TYPE_DWORD);
            kFox::MemoryOffset( "40", -16, Type::TYPE_DWORD);
            kFox::MemoryWrite( "100416", 4, Type::TYPE_DWORD);
            kFox::MemoryWrite( "10126002", 8, Type::TYPE_DWORD);
            kFox::MemorySearch( "10126201", Type::TYPE_DWORD);
            kFox::MemoryOffset( "40", -16, Type::TYPE_DWORD);
            kFox::MemoryWrite( "100416", 4, Type::TYPE_DWORD);
            kFox::MemoryWrite( "10126002", 8, Type::TYPE_DWORD);
            kFox::MemorySearch( "74474", Type::TYPE_DWORD);
            kFox::MemoryOffset( "75651", -8, Type::TYPE_DWORD);
            kFox::MemoryWrite( "100584", -20, Type::TYPE_DWORD);
            Dlq = true;
            kFox::ClearResult();
           }
		   if (Config.ExtraMenu.Oden) {
			   kFox::SetSearchRange(RegionType::ANONYMOUS);
                        kFox::MemorySearch("10125001", Type::TYPE_DWORD);
                        kFox::MemoryOffset("1880000001", 24, Type::TYPE_DWORD);
                        kFox::MemoryWrite("16843009", -12, Type::TYPE_DWORD);
                        kFox::MemoryWrite("1", -8, Type::TYPE_DWORD);
                        kFox::MemoryWrite("5", 8, Type::TYPE_DWORD);
                        kFox::MemoryWrite("400008", 52, Type::TYPE_DWORD);
                        kFox::MemoryWrite("200132", 56, Type::TYPE_DWORD);
                        kFox::MemoryWrite("500048", 60, Type::TYPE_DWORD);

                        kFox::MemorySearch("10125001", Type::TYPE_DWORD);
                        kFox::MemoryOffset("39", -16, Type::TYPE_DWORD);
                        kFox::MemoryWrite("100287", 4, Type::TYPE_DWORD);
                        kFox::MemoryWrite("10125002", 8, Type::TYPE_DWORD);

                        kFox::MemorySearch("10125201", Type::TYPE_DWORD);
                        kFox::MemoryOffset("39", -16, Type::TYPE_DWORD);
                        kFox::MemoryWrite("100287", 4, Type::TYPE_DWORD);
                        kFox::MemoryWrite("10125002", 8, Type::TYPE_DWORD);

                        kFox::MemorySearch("10125001", Type::TYPE_DWORD);
                        kFox::MemoryOffset("1057803469", 16, Type::TYPE_DWORD);
                        kFox::MemoryWrite("70111", -12, Type::TYPE_DWORD); 
			   Oden = true;
            kFox::ClearResult();
           }
		   if (Config.ExtraMenu.Holger) {
			   kFox::SetSearchRange(RegionType::ANONYMOUS);
                        kFox::MemorySearch("10309001", Type::TYPE_DWORD);
                        kFox::MemoryOffset("1880000001", 24, Type::TYPE_DWORD);
                        kFox::MemoryWrite("16843009", -12, Type::TYPE_DWORD);
                        kFox::MemoryWrite("1", -8, Type::TYPE_DWORD);
                        kFox::MemoryWrite("5", 8, Type::TYPE_DWORD);
                        kFox::MemoryWrite("400003", 52, Type::TYPE_DWORD);
                        kFox::MemoryWrite("200072", 56, Type::TYPE_DWORD);
                        kFox::MemoryWrite("400007", 60, Type::TYPE_DWORD);

                        kFox::MemorySearch("10309001", Type::TYPE_DWORD);
                        kFox::MemoryOffset("3084", -16, Type::TYPE_DWORD);
                        kFox::MemoryWrite("10520", 4, Type::TYPE_DWORD);
                        kFox::MemoryWrite("10309002", 8, Type::TYPE_DWORD);

                        kFox::MemorySearch("10309201", Type::TYPE_DWORD);
                        kFox::MemoryOffset("3084", -16, Type::TYPE_DWORD);
                        kFox::MemoryWrite("10520", 4, Type::TYPE_DWORD);
                        kFox::MemoryWrite("10309002", 8, Type::TYPE_DWORD);

                        kFox::MemorySearch("10309001", Type::TYPE_DWORD);
                        kFox::MemoryOffset("1057803469", 16, Type::TYPE_DWORD);
                        kFox::MemoryWrite("200010357", -12, Type::TYPE_DWORD);           
			   Holger = true;
            kFox::ClearResult();
           }
            if (Config.ExtraMenu.Dlq2) {
            kFox::SetSearchRange(RegionType::ANONYMOUS);
            kFox::MemorySearch( "10207001", Type::TYPE_DWORD);
            kFox::MemoryOffset( "1057803469", 16, Type::TYPE_DWORD);
            kFox::MemoryWrite( "79116", -12, Type::TYPE_DWORD);
           
            
            kFox::MemorySearch( "10207001", Type::TYPE_DWORD);
            kFox::MemoryOffset( "1035", -16, Type::TYPE_DWORD);
            kFox::MemoryWrite( "100531", 4, Type::TYPE_DWORD);
            kFox::MemoryWrite( "10207155", 8, Type::TYPE_DWORD);
            
            kFox::MemorySearch( "10207001", Type::TYPE_DWORD);
            kFox::MemoryOffset( "1880000001", 24, Type::TYPE_DWORD);
            kFox::MemoryWrite( "16843009", -12, Type::TYPE_DWORD);
            kFox::MemoryWrite( "1", 8, Type::TYPE_DWORD);
            kFox::MemoryWrite( "5", -8, Type::TYPE_DWORD);
            kFox::MemoryWrite( "0", 32, Type::TYPE_DWORD);
            kFox::MemoryWrite( "400012", 52, Type::TYPE_DWORD);
            kFox::MemoryWrite( "200175", 56, Type::TYPE_DWORD);
            kFox::MemoryWrite( "300168", 60, Type::TYPE_DWORD);
            Dlq2 = true;
            kFox::ClearResult();
           }
        if (Config.ExtraMenu.Tang) {
            kFox::SetSearchRange(RegionType::ANONYMOUS);
            kFox::MemorySearch( "10702999", Type::TYPE_DWORD);
            kFox::MemoryOffset( "1880000001", 0x18, Type::TYPE_DWORD);
            kFox::MemoryOffset( "50", 0x1C, Type::TYPE_DWORD);
           kFox::MemoryWrite( "10717001", 0x60, Type::TYPE_DWORD);
            
            kFox::MemorySearch( "10702999", Type::TYPE_DWORD);
            kFox::MemoryOffset( "1880000001", 0x18, Type::TYPE_DWORD);
            kFox::MemoryOffset( "0", 0x1C, Type::TYPE_DWORD);
            kFox::MemoryOffset( "300152", 0x3C, Type::TYPE_DWORD);
            kFox::MemoryOffset( "10717001", 0x60, Type::TYPE_DWORD);           
            kFox::MemoryWrite( "10702999", 0x60, Type::TYPE_DWORD);
            
            kFox::MemorySearch( "10702999", Type::TYPE_DWORD);
            kFox::MemoryOffset( "1880000001", 0x18, Type::TYPE_DWORD);
            kFox::MemoryWrite( "16843009", -0xC, Type::TYPE_DWORD);
            kFox::MemoryWrite( "1", -0x8, Type::TYPE_DWORD);
            kFox::MemoryWrite( "4", 0x8, Type::TYPE_DWORD);
            kFox::MemoryWrite( "200159", 0x38, Type::TYPE_DWORD);
            kFox::MemoryWrite( "300152", 0x3C, Type::TYPE_DWORD);
            
            kFox::MemorySearch( "10702999", Type::TYPE_DWORD);
            kFox::MemoryOffset( "6145", -0x10, Type::TYPE_DWORD);
            kFox::MemoryWrite( "100424", 4, Type::TYPE_DWORD);
            kFox::MemoryWrite( "10717001", 8, Type::TYPE_DWORD);
            
            kFox::MemorySearch( "10702201", Type::TYPE_DWORD);
            kFox::MemoryOffset( "6145", -0x10, Type::TYPE_DWORD);
            kFox::MemoryWrite( "100424", 4, Type::TYPE_DWORD);
            kFox::MemoryWrite( "10717001", 8, Type::TYPE_DWORD);
            
            kFox::MemorySearch( "10702999", Type::TYPE_DWORD);
            kFox::MemoryOffset( "1057803469", 0x10, Type::TYPE_DWORD);
            kFox::MemoryWrite( "74694", -0xC, Type::TYPE_DWORD);


            Tang = true;
            
            kFox::ClearResult();
           }
           if (Config.ExtraMenu.Spec) {
            kFox::SetSearchRange(RegionType::ANONYMOUS);
            kFox::MemorySearch( "710001101", Type::TYPE_DWORD);
            kFox::MemoryOffset( "710000042", -32, Type::TYPE_DWORD);
            kFox::MemoryOffset( "710001102", 4, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710002569", -44, Type::TYPE_DWORD);
           kFox::MemoryWrite( "0", -40, Type::TYPE_DWORD);
            kFox::MemoryWrite( "289900106", -36, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710002568", -28, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710002569", -24, Type::TYPE_DWORD);
            kFox::MemoryWrite( "0", -16, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710002570", -12, Type::TYPE_DWORD);
            Spec = true;
            kFox::ClearResult();
           }
           if (Config.ExtraMenu.Sop) {
            kFox::SetSearchRange(RegionType::ANONYMOUS);
            kFox::MemorySearch( "710001101", Type::TYPE_DWORD);
            kFox::MemoryOffset( "710000042", -32, Type::TYPE_DWORD);
            kFox::MemoryOffset( "710001102", 4, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710002643", -44, Type::TYPE_DWORD);
           kFox::MemoryWrite( "289900109", -40, Type::TYPE_DWORD);
            kFox::MemoryWrite( "0", -36, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710002574", -28, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710002643", -24, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710002576", -16, Type::TYPE_DWORD);
            kFox::MemoryWrite( "100000016", -12, Type::TYPE_DWORD);
            Sop = true;
            kFox::ClearResult();
           }
           if (Config.ExtraMenu.Pan) {
            kFox::SetSearchRange(RegionType::ANONYMOUS);
            kFox::MemorySearch( "710001101", Type::TYPE_DWORD);
            kFox::MemoryOffset( "710000042", -32, Type::TYPE_DWORD);
            kFox::MemoryOffset( "710001102", 4, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710002263", -44, Type::TYPE_DWORD);
           kFox::MemoryWrite( "289900064", -40, Type::TYPE_DWORD);
            kFox::MemoryWrite( "0", -36, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710002265", -28, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710002263", -24, Type::TYPE_DWORD);
            kFox::MemoryWrite( "0", -16, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710002264", -12, Type::TYPE_DWORD);
            Pha = true;
            kFox::ClearResult();
           }
           if (Config.ExtraMenu.Ali) {
            kFox::SetSearchRange(RegionType::ANONYMOUS);
            kFox::MemorySearch( "710001101", Type::TYPE_DWORD);
            kFox::MemoryOffset( "710000042", -32, Type::TYPE_DWORD);
            kFox::MemoryOffset( "710001102", 4, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710002334", -44, Type::TYPE_DWORD);
           kFox::MemoryWrite( "289900085", -40, Type::TYPE_DWORD);
            kFox::MemoryWrite( "0", -36, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710002333", -28, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710002334", -24, Type::TYPE_DWORD);
            kFox::MemoryWrite( "0", -16, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710002335", -12, Type::TYPE_DWORD);
            Ali = true;
            kFox::ClearResult();
           }
           if (Config.ExtraMenu.Nik) {
            kFox::SetSearchRange(RegionType::ANONYMOUS);
            kFox::MemorySearch( "710001101", Type::TYPE_DWORD);
            kFox::MemoryOffset( "710000042", -32, Type::TYPE_DWORD);
            kFox::MemoryOffset( "710001102", 4, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710000891", -44, Type::TYPE_DWORD);
           kFox::MemoryWrite( "310000170", -40, Type::TYPE_DWORD);
            kFox::MemoryWrite( "0", -36, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710000893", -28, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710000891", -24, Type::TYPE_DWORD);
            kFox::MemoryWrite( "0", -16, Type::TYPE_DWORD);
            kFox::MemoryWrite( "710000892", -12, Type::TYPE_DWORD);
            Nik = true;
            kFox::ClearResult();
           }
           if (Config.ExtraMenu.Krm) {
            kFox::SetSearchRange(RegionType::ANONYMOUS);
            kFox::MemorySearch( "10508002", Type::TYPE_DWORD);
            kFox::MemoryOffset( "10508003", -128, Type::TYPE_DWORD);
            kFox::MemoryWrite( "70247", -12, Type::TYPE_DWORD);
           
            
            kFox::MemorySearch( "10508002", Type::TYPE_DWORD);
            kFox::MemoryOffset( "28", -8, Type::TYPE_DWORD);
            kFox::MemoryWrite( "300128", -36, Type::TYPE_DWORD);
            kFox::MemoryWrite( "200135", -40, Type::TYPE_DWORD);
            kFox::MemoryWrite( "0", -44, Type::TYPE_DWORD);
            kFox::MemoryWrite( "0", -64, Type::TYPE_DWORD);
            kFox::MemoryWrite( "4", -88, Type::TYPE_DWORD);
            kFox::MemoryWrite( "4", -104, Type::TYPE_DWORD);
            
            kFox::MemorySearch( "10503001", Type::TYPE_DWORD);
            kFox::MemoryOffset( "4108", -12, Type::TYPE_DWORD);
            kFox::MemoryWrite( "10508044", 4, Type::TYPE_DWORD);
            kFox::MemoryWrite( "100322", 8, Type::TYPE_DWORD);
            kFox::MemoryWrite( "10508044", 12, Type::TYPE_DWORD);

            Krm = true;
            kFox::ClearResult();
           }
           if (Config.ExtraMenu.Dlq22) {
            kFox::SetSearchRange(RegionType::ANONYMOUS);
            kFox::MemorySearch( "10207001", Type::TYPE_DWORD);
            kFox::MemoryOffset( "10207002", -128, Type::TYPE_DWORD);
            kFox::MemoryWrite( "200002339", -12, Type::TYPE_DWORD);
           
            
            kFox::MemorySearch( "10207001", Type::TYPE_DWORD);
            kFox::MemoryOffset( "28", -8, Type::TYPE_DWORD);
            kFox::MemoryWrite( "300081", -36, Type::TYPE_DWORD);
            kFox::MemoryWrite( "300081", -40, Type::TYPE_DWORD);
            kFox::MemoryWrite( "0", -44, Type::TYPE_DWORD);
            kFox::MemoryWrite( "0", -64, Type::TYPE_DWORD);
            kFox::MemoryWrite( "4", -88, Type::TYPE_DWORD);
            kFox::MemoryWrite( "4", -104, Type::TYPE_DWORD);
            
            kFox::MemorySearch( "10207001", Type::TYPE_DWORD);
            kFox::MemoryOffset( "1035", -12, Type::TYPE_DWORD);
            kFox::MemoryWrite( "10207022", 4, Type::TYPE_DWORD);
            kFox::MemoryWrite( "84", 8, Type::TYPE_DWORD);
            kFox::MemoryWrite( "10207022", 12, Type::TYPE_DWORD);

            Dl = true;
            kFox::ClearResult();
           }
        if (Config.ExtraMenu.Cb) {
            kFox::SetSearchRange(RegionType::ANONYMOUS);
            kFox::MemorySearch( "10420001", Type::TYPE_DWORD);
            kFox::MemoryOffset( "1880000001", 24, Type::TYPE_DWORD);
            kFox::MemoryWrite( "16843009", -12, Type::TYPE_DWORD);
            kFox::MemoryWrite( "1", -8, Type::TYPE_DWORD);
            kFox::MemoryWrite( "5", 8, Type::TYPE_DWORD);
            kFox::MemoryWrite( "400005", 52, Type::TYPE_DWORD);
            kFox::MemoryWrite( "200102", 56, Type::TYPE_DWORD);
            kFox::MemoryWrite( "500032", 60, Type::TYPE_DWORD);
            kFox::MemorySearch( "10420001", Type::TYPE_DWORD);
            kFox::MemoryOffset( "2073", -16, Type::TYPE_DWORD);
            kFox::MemoryWrite( "100082", 4, Type::TYPE_DWORD);
            kFox::MemoryWrite( "10420002", 8, Type::TYPE_DWORD);
            
            kFox::MemorySearch( "10420201", Type::TYPE_DWORD);
            kFox::MemoryOffset( "2073", -16, Type::TYPE_DWORD);
            kFox::MemoryWrite( "100082", 4, Type::TYPE_DWORD);
            kFox::MemoryWrite( "10420002", 8, Type::TYPE_DWORD);
            
            kFox::MemorySearch( "10420001", Type::TYPE_DWORD);
            kFox::MemoryOffset( "1057803469", 16, Type::TYPE_DWORD);
            kFox::MemoryWrite( "7778", -12, Type::TYPE_DWORD);
            Cb = true;
            kFox::ClearResult();
        }
        if (Config.ExtraMenu.Kol) {
            kFox::SetSearchRange(RegionType::ANONYMOUS);
            kFox::MemorySearch( "10124001", Type::TYPE_DWORD);
            kFox::MemoryOffset( "1880000001", 24, Type::TYPE_DWORD);
            kFox::MemoryWrite( "16843009", -12, Type::TYPE_DWORD);
            kFox::MemoryWrite( "1", -8, Type::TYPE_DWORD);
            kFox::MemoryWrite( "5", 8, Type::TYPE_DWORD);
            kFox::MemoryWrite( "400006", 52, Type::TYPE_DWORD);
            kFox::MemoryWrite( "200112", 56, Type::TYPE_DWORD);
            kFox::MemoryWrite( "300105", 60, Type::TYPE_DWORD);
            
            kFox::MemorySearch( "10124001", Type::TYPE_DWORD);
            kFox::MemoryOffset( "38", -16, Type::TYPE_DWORD);
            kFox::MemoryWrite( "100155", 4, Type::TYPE_DWORD);
            kFox::MemoryWrite( "10125002", 8, Type::TYPE_DWORD);
            
            kFox::MemorySearch( "10125201", Type::TYPE_DWORD);
            kFox::MemoryOffset( "39", -16, Type::TYPE_DWORD);
            kFox::MemoryWrite( "100287", 4, Type::TYPE_DWORD);
            kFox::MemoryWrite( "10125002", 8, Type::TYPE_DWORD);
            
            kFox::MemorySearch( "10124001", Type::TYPE_DWORD);
            kFox::MemoryOffset( "1057803469", 16, Type::TYPE_DWORD);
            kFox::MemoryWrite( "9479", -12, Type::TYPE_DWORD);
            Kol = true;
            kFox::ClearResult();
        }
        if (Config.ExtraMenu.Mol) {
            kFox::SetSearchRange(RegionType::ANONYMOUS);
            kFox::MemorySearch( "10122001", Type::TYPE_DWORD);
            kFox::MemoryOffset( "1880000001", 24, Type::TYPE_DWORD);
            kFox::MemoryWrite( "16843009", -12, Type::TYPE_DWORD);
            kFox::MemoryWrite( "1", -8, Type::TYPE_DWORD);
            kFox::MemoryWrite( "5", 8, Type::TYPE_DWORD);
            kFox::MemoryWrite( "400002", 52, Type::TYPE_DWORD);
            kFox::MemoryWrite( "200089", 56, Type::TYPE_DWORD);
            kFox::MemoryWrite( "500030", 60, Type::TYPE_DWORD);
            
            kFox::MemorySearch( "10122001", Type::TYPE_DWORD);
            kFox::MemoryOffset( "36", -16, Type::TYPE_DWORD);
            kFox::MemoryWrite( "100004", 4, Type::TYPE_DWORD);
            kFox::MemoryWrite( "10122002", 8, Type::TYPE_DWORD);
            
            kFox::MemorySearch( "10122201", Type::TYPE_DWORD);
            kFox::MemoryOffset( "39", -16, Type::TYPE_DWORD);
            kFox::MemoryWrite( "100004", 4, Type::TYPE_DWORD);
            kFox::MemoryWrite( "10122002", 8, Type::TYPE_DWORD);
            
            kFox::MemorySearch( "10122001", Type::TYPE_DWORD);
            kFox::MemoryOffset( "1057803469", 16, Type::TYPE_DWORD);
            kFox::MemoryWrite( "1175", -12, Type::TYPE_DWORD);
            Kol = true;
            kFox::ClearResult();
        }
             
            if (Config.ExtraMenu.Hid) {
                 kFox::SetSearchRange(RegionType::ANONYMOUS);
            kFox::MemorySearch( "0.1439999938", Type::TYPE_FLOAT);
            kFox::MemoryWrite( "3", 0, Type::TYPE_FLOAT);
            
            kFox::ClearResult();
            He1 = true;
       
            }
        
       
            
        auto td = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count() - t1;
        std::this_thread::sleep_for(std::chrono::milliseconds(std::max(std::min(0LL, SLEEP_TIME - td), SLEEP_TIME)));
    }
    return nullptr;
}

bool (*orig_RadarMap)(void *instance);
bool getRadarMap(void *instance) {
    if (instance != NULL) {
        if (Config.ExtraMenu.Outline) {
             return true;
        }
    }
    return orig_RadarMap(instance);
}

float (*orig_Reload)(void *instance);
float getReload(void *instance) {
    if (instance != NULL) {
        if (Config.ExtraMenu.Reload) {
            return 0.000001;
        }
    }
    return orig_Reload(instance);
}

float (*old_Xshoter1)(void *instance);
float Xshoter1(void *instance) {
    if (instance != NULL) {
      if (Config.ExtraMenu.Recoil) {
           return 0.0000001;
        }
    }
    return old_Xshoter1(instance);
}

float (*orig_ShotSpread)(void *instance);
float getShotSpread(void *instance) {
    if (instance != NULL) {
      if (Config.ExtraMenu.Spread) {
           return 0.0000001;
        }
    }
    return orig_ShotSpread(instance);
}

float (*old_Xshoter6)(void *instance);
float Xshoter6(void *instance) {
    if (instance != NULL) {
      if (Config.ExtraMenu.Scope) {
           return 0.01;
        }
    }
    return old_Xshoter6(instance);
}

float (*orig_switch)(void *instance);
float getSwitch(void *instance) {
    if (instance != NULL) {
      if (Config.ExtraMenu.Switch) {
           return 0.0000001;
        }
    }
    return orig_switch(instance);
}

bool (*old_SingleLineCheckPhysics)(void *instance, int hitType, void *hitTarget, void *hitCollider, Vector3 startPos, Vector3 dir, void *impactInfo);
bool SingleLineCheckPhysics(void *instance, int hitType, void *hitTarget, void *hitCollider, Vector3 startPos, Vector3 dir, void *impactInfo) {
    if (instance != NULL) {
      if (Config.ExtraMenu.Buff) {      
           return true;
        }      
    }
    return old_SingleLineCheckPhysics(instance, hitType, hitTarget, hitCollider, startPos, dir, impactInfo);
}

float (*orig_overheat)(void *instance);
float getOverHeat(void *instance) {
    if (instance != NULL) {
      if (Config.ExtraMenu.Heat) {
           return 0.0000001;
        }      
    }
    return orig_overheat(instance);
}

float (*orig_Zgcross7)(void *instance);
float Zgcross7(void *instance) {
    if (instance != NULL) {
        if (Config.ExtraMenu.Smallcross) {
            return 0;
        }
    }
    return orig_Zgcross7(instance);
}

float (*orig_fastswim)(void *instance);
float getFastSwim(void *instance) {
    if (instance != NULL) {
   if (Config.ExtraMenu.Swim) {
           return 2.9;
        }
    }
    return orig_fastswim(instance);
}

bool (*orig_br)(void *instance);
bool getbr(void *instance) {
    if (instance != NULL) {
        if (Config.ExtraMenu.Parachute) {
             return true;
        }
    }
    return orig_br(instance);
}

bool (*orig_cost)(void *instance);
bool getcost(void *instance) {
    if (instance != NULL) {
      if (Config.ExtraMenu.Cost) {
             return true;
        }
    }
    return orig_cost(instance);
}

float (*old_GetFireValue)(void *instance, float fireInterval);
float GetFireValue(void *instance, float fireInterval) {
    if (instance != NULL) {
      if (Config.ExtraMenu.Rate) {      
           return 75.f;
           
        }      
    }
    return old_GetFireValue(instance, fireInterval);
}

bool (*orig_Zgfire8)(void *instance);
bool Zgfire8(void *instance) {
    if (instance != NULL) {
      if (Config.ExtraMenu.Auto) {      
           return false;
        }      
    }
    return orig_Zgfire8(instance);
}

bool (*old_IsAimTargetCanAutoFire)(void *instance, void *weap);
bool IsAimTargetCanAutoFire(void *instance, void *weap) {
    if (instance != NULL) {
      if (Config.ExtraMenu.Fire) {      
           return true;
        }      
    }
    return old_IsAimTargetCanAutoFire(instance, weap);
}

float (*orig_Zgspeed14)(void *instance);
float Zgspeed14(void *instance) {
    if (instance != NULL) {
      if (Config.ExtraMenu.Speed) {      
           return Config.ExtraMenu.SizeSpeed;
        }      
    }
    return orig_Zgspeed14(instance);
}

bool (*orig_AdvanceUAV)(void *instance);
bool getAdvanceUAV(void *instance) {
    if (instance != NULL) {
        if (Config.ExtraMenu.Uav) {
             return true;
        }
    }
    return orig_AdvanceUAV(instance);
}

float (*orig_PlayerControllerGetRotateSpeed)(void *instance, float assistDis, float dis, float angle, float rotateTime, bool gamepadInput);
float _PlayerControllerGetRotateSpeed(void *instance, float assistDis, float dis, float angle, float rotateTime, bool gamepadInput) {
    if (instance != NULL) {
    
        if (Config.ExtraMenu.AimAssist) {
        
            return (float) Config.ExtraMenu.SizeAim;
        }
    }
    return orig_PlayerControllerGetRotateSpeed(instance, assistDis, dis, angle, rotateTime, gamepadInput);
}

float (*orig_PlayerControllerGetAssitAimSpeed)(void *instance, Vector3 assistCentorPos, float assistDis, float dis, float angle, bool isPVE, bool gamepadInput);
float _PlayerControllerGetAssitAimSpeed(void *instance, Vector3 assistCentorPos, float assistDis, float dis, float angle, bool isPVE, bool gamepadInput) {
    if (instance != NULL) {
    
        if (Config.ExtraMenu.AimAssist) {
        
            return (float) Config.ExtraMenu.SizeAim;
}
}
    return orig_PlayerControllerGetAssitAimSpeed(instance, assistCentorPos, assistDis, dis, angle, isPVE, gamepadInput);
}

float (*orig_GetAssistAimRotateTime)(void *instance, float dis, bool gamepadInput);
float _GetAssistAimRotateTime(void *instance, float dis, bool gamepadInput) {
    if (instance != NULL) {
        if (Config.ExtraMenu.AimAssist2) {
            return (float) Config.ExtraMenu.SizeAim2;
            *(float *) ((uintptr_t) instance + 0x1B61E34) = Config.ExtraMenu.SizeAim2;
        }
    }
    return orig_GetAssistAimRotateTime(instance, dis, gamepadInput);
}

float (*orig_GetAutoAssistAimRate)(void *instance, float dist, float toQuasiDist, bool isMPPVE, float aimAngle, bool gamepadInput);
float _GetAutoAssistAimRate(void *instance, float dist, float toQuasiDist, bool isMPPVE, float aimAngle, bool gamepadInput) {
    if (instance != NULL) {
        if (Config.ExtraMenu.AimAssist2) {
            return (float) Config.ExtraMenu.SizeAim2;
            *(float *) ((uintptr_t) instance + 0x1B622FC) = Config.ExtraMenu.SizeAim2;
        }
    }
    return orig_GetAutoAssistAimRate(instance, dist, toQuasiDist, isMPPVE, aimAngle, gamepadInput);
}

float (*old_Xshoter9)(void *instance);
float Xshoter9(void *instance) {
    if (instance != NULL) {
        if (Config.ExtraMenu.Slide) {
           return Config.ExtraMenu.SizeSlide;
        }
     }
    return old_Xshoter9(instance);
}

float (*orig_jumper)(void *instance);
float getJumper(void *instance) {
    if (instance != NULL) {
      if (Config.ExtraMenu.Jump) {
           return Config.ExtraMenu.SizeJump;
        }
    }
    return orig_jumper(instance);
}

bool (*orig_framerate)(void *instance);
bool getframerate(void *instance) {
    if (instance != NULL) {
        if (Config.ExtraMenu.Framerate) {
             return true;
        }
    }
    return orig_framerate(instance);
}

int (*old_GetFrameRateValue)(void *instance, int fl, int mode);
int GetFrameRateValue(void *instance, int fl, int mode) {
    if (instance != NULL) {
      if (Config.ExtraMenu.Fps) {      
           return 120;
           
        }      
    }
    return old_GetFrameRateValue(instance, fl, mode);
}


void *Init_Thread2() {
		do {
        sleep(1);
    } while (!isLibraryLoaded("libanogs.so")|!isLibraryLoaded("libil2cpp.so")|!isLibraryLoaded("libunity.so"));
	
     address = findLibrary("libanogs.so");
	 address = findLibrary("libil2cpp.so");
	 address = findLibrary("libunity.so");
	
 
//BYPASS BY RYUU
MemoryPatch::createWithHex("libanogs.so", 0xB08CC, "1E FF 2F E1").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x10CC, "00 00 A0 E3").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x10D0, "65 00 6E 00").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x10D4, "65 6C 74 00").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x10D8, "70 6F 74 00").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x10DC, "44 61 74 00").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x718A8, "1E FF 2F E1").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x240F8, "00 00 00 17").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x4AF34, "E8 BD B0 02").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x4AF44, "E8 BD B0 02").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x4AF48, "E8 BD 0B 00").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x4AFA8, "F0 00 28 00").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x5A1F0, "F2 42 90 05").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x5A244, "F4 4F 46 21").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x5A248, "F2 1D 62 DC").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x5A284, "F0 08 F8 56").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x5A31C, "F2 1D A8 01").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x718A8, "00 00 00 00").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x4D4B820, "B4 23 1C 00").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x2C5A28, "A2 3E 04 00").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x2C73E0, "6C 70 01 00").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x71FC4, "00 26 50 F8").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x71FEC, "0E 46 EE F1").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x71F20, "01 26 50 F8").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x71F40, "9F 46 40 F6").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x71FA4, "0E 04 50 F8").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x6861C, "11 46 F9 F7").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x688EC, "A8 F8 04 00").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x2C7520, "0C 71 01 00").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x2C7528, "10 71 01 00").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x85A0, "17 00 00 00").Modify();
MemoryPatch::createWithHex("libanogs.so", 0x8640, "17 00 00 00").Modify();



//Skip tutorial
sleep(5);
MemoryPatch::createWithHex("libil2cpp.so", 0x4d0d13c, "01 00 A0 E3").Modify();
MemoryPatch::createWithHex("libil2cpp.so", 0x4d0d140, "1E FF 2F E1").Modify();

//Clear Guest
hexPatches.Guest1 = MemoryPatch::createWithHex("libil2cpp.so",0x6030C78,"00 00 A0 E3");
hexPatches.Guest2 = MemoryPatch::createWithHex("libil2cpp.so",0x6030C7C,"1E FF 2F E1");


//Medium Aim DONE
hexPatches.Mediumaim1 = MemoryPatch::createWithHex("libil2cpp.so",0x22A4DE8,"33 01 44 E3");
hexPatches.Mediumaim2 = MemoryPatch::createWithHex("libil2cpp.so",0x22A4DEC,"1E FF 2F E1");

//Wallhack
hexPatches.Norwall = MemoryPatch::createWithHex("libil2cpp.so",0x16B66D0,"00 00 00 00");
 
		hexPatches.Dark1 = MemoryPatch::createWithHex("libunity.so",0x1595b4, "00 00 27 41");
    hexPatches.Dark2 = MemoryPatch::createWithHex("libunity.so",0x1617d4, "00 00 00 00"); //
      
	hexPatches.Fastshoot1 = MemoryPatch::createWithHex("libil2cpp.so", 0x23dc470, "00 00 00 00");
    hexPatches.Fastshoot2 = MemoryPatch::createWithHex("libil2cpp.so", 0x23dc880, "00 00 00 00");
    hexPatches.Fastshoot3 = MemoryPatch::createWithHex("libil2cpp.so", 0x23dc9a4, "00 00 00 00");
    hexPatches.Fastshoot4 = MemoryPatch::createWithHex("libil2cpp.so", 0x23dd93c, "00 00 00 00");
 
	
	hexPatches.Fastscope1 = MemoryPatch::createWithHex("libil2cpp.so",0x19caaa4,"300E43E3");
    hexPatches.Fastscope2 = MemoryPatch::createWithHex("libil2cpp.so",0x19caaa8,"1EFF2FE1");   
   
	
hexPatches.Wireframe = MemoryPatch::createWithHex("libunity.so",0x640e78, "00 00 00 00");

hexPatches.Flashbang = MemoryPatch::createWithHex("libil2cpp.so",string2Offset(OBFUSCATE("0x1A76090")),OBFUSCATE("1E FF 2F E1"));

    return 0;
}

void Init_Thread() {
    while (!m_Il2Cpp) {
        m_Il2Cpp = Tools::GetBaseAddress(m_IL2CPPLIB);
		sleep(1);
		
}    
    LOGI("libil2cpp.so: %p", m_Il2Cpp);

    Il2CppAttach();
    sleep(5);
    std::thread(Main_Thread).detach();
	
	  //Wallhack Outline
      Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"), OBFUSCATE("GameBase"), OBFUSCATE("EffectInstance_SeeFront"), OBFUSCATE("IsEffectActive")), (void *) getRadarMap, (void **) &orig_RadarMap); 
	  Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"), OBFUSCATE("GameBase"), OBFUSCATE("EffectInstance_SeeFrontGlow"), OBFUSCATE("IsEffectActive")), (void *) getRadarMap, (void **) &orig_RadarMap);	
	  
	  //No Recoil
	  Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"),OBFUSCATE("GameEngine"),OBFUSCATE("WeaponFireComponent_Instant") , OBFUSCATE("GetScaleRecoil")), (void *)  &Xshoter1, (void **) &old_Xshoter1);
	  
	  //Fast Scope
	  Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"),OBFUSCATE("GameBase"),OBFUSCATE("Weapon") , OBFUSCATE("get_AimingTime")), (void *)  &Xshoter6, (void **) &old_Xshoter6);
	  
      // Fire Rate
      Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"),OBFUSCATE("GameBase"),OBFUSCATE("Weapon") , OBFUSCATE("GetFastAmmoInterval"), 1), (void *)  &GetFireValue, (void **) &old_GetFireValue);
	  
      // Auto Fire
      Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"),OBFUSCATE("GameEngine"),OBFUSCATE("PlayerController") , OBFUSCATE("IsAimTargetCanAutoFire"), 1), (void *)  &IsAimTargetCanAutoFire, (void **) &old_IsAimTargetCanAutoFire);
	  
  	  // Shot Cost
      Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"),OBFUSCATE("GameEngine"),OBFUSCATE("Weapon") , OBFUSCATE("get_ShotCost")), (void *)  &getcost, (void **) &orig_cost);
	  
      // Fast Switch
      Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"),OBFUSCATE("GameBase"),OBFUSCATE("Weapon") , OBFUSCATE("get_EquipTime")), (void *)  &getSwitch, (void **) &orig_switch); 
	  
	  // Fast Swim
      Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"),OBFUSCATE("GameBase"),OBFUSCATE("PlayerPawn") , OBFUSCATE("CalcSwimmingSpeedScale")), (void *)  &getFastSwim, (void **) &orig_fastswim);  
	  
      //High Jump
      Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"),OBFUSCATE("GameBase"),OBFUSCATE("Pawn"), OBFUSCATE("get_MaxJumpHeightScale")), (void *) &getJumper, (void **) &orig_jumper);
	  
	  //Buff Damage
	  Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"),OBFUSCATE("GameEngine"),OBFUSCATE("WeaponFireComponent_Instant") , OBFUSCATE("SingleLineCheckPhysics"), 6), (void *)  &SingleLineCheckPhysics, (void **) &old_SingleLineCheckPhysics);
	  
	  //SPEED HACK
      Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset("Assembly-CSharp.dll","GameEngine","PlayerInfo" , "get_MoveSpeedScale"), (void *) Zgspeed14, (void **) &orig_Zgspeed14);
	  
      //Long Slide
      Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset("Assembly-CSharp.dll","GameBase","SlideTackleComponent" , "get_SlideTackleSpeed"), (void *) &Xshoter9, (void **) &old_Xshoter9);
	  
      // No overheat RPD
      Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"),OBFUSCATE("GameEngine"),OBFUSCATE("WeaponFireComponent") , OBFUSCATE("get_AddHotTime")), (void *)  getOverHeat, (void **) &orig_overheat);
	  
      //No Reload   
      Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"), OBFUSCATE("GameEngine"), OBFUSCATE("WeaponFireComponent"), OBFUSCATE("get_ChangeClipTime")), (void *) getReload, (void **) &orig_Reload);
	  
      //No Parachute
      Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"), OBFUSCATE("GameBase"), OBFUSCATE("SkydivingPhysics"), OBFUSCATE("OpenParachute"), 1), (void *) &getbr, (void **) &orig_br);
	  
      //No Spread
      Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"),OBFUSCATE("GameEngine"),OBFUSCATE("WeaponFireComponent_Instant") , OBFUSCATE("MinInaccuracy")), (void *)  getShotSpread, (void **) &orig_ShotSpread);
      Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"),OBFUSCATE("GameEngine"),OBFUSCATE("WeaponFireComponent_Instant") , OBFUSCATE("MaxInaccuracy")), (void *)  getShotSpread, (void **) &orig_ShotSpread);
	  
      //Aim Assist  
      Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"), OBFUSCATE("GameEngine"), OBFUSCATE("PlayerController"), OBFUSCATE("GetRotateSpeed"), 5), (void *) _PlayerControllerGetRotateSpeed, (void **) &orig_PlayerControllerGetRotateSpeed);
      Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"), OBFUSCATE("GameEngine"), OBFUSCATE("PlayerController"), OBFUSCATE("GetAssitAimSpeed"), 6), (void *) _PlayerControllerGetAssitAimSpeed, (void **) &orig_PlayerControllerGetAssitAimSpeed);
	  
      //Aim Assist Sniper
      Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"), OBFUSCATE("GameBase"), OBFUSCATE("Weapon"), OBFUSCATE("GetAssistAimRotateTime"), 2), (void *) _GetAssistAimRotateTime, (void **) &orig_GetAssistAimRotateTime);
      Tools::Hook((void *) (uintptr_t)Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"), OBFUSCATE("GameBase"), OBFUSCATE("Weapon"), OBFUSCATE("GetAutoAssistAimRate"), 5), (void *) _GetAutoAssistAimRate, (void **) &orig_GetAutoAssistAimRate);
	  
      //Bullet Track 360
      Tools::Hook(Il2CppGetMethodOffset("Assembly-CSharp.dll", "GameEngine", "WeaponFireComponent_Instant", "CreateBulletLine", 3), (void *)WeaponFireComponent_Instant_CreateBulletLine, (void **)&oWeaponFireComponent_Instant_CreateBulletLine);
      Tools::Hook(Il2CppGetMethodOffset(OBFUSCATE("Assembly-CSharp.dll"), OBFUSCATE("GameEngine"), OBFUSCATE("WeaponFireComponent_Instant"), OBFUSCATE("CreateBulletProjectile"), 7), (void *)WeaponFireComponent_Instant_CreateBulletProjectile, (void **)&oWeaponFireComponent_Instant_CreateBulletProjectile);
	  
	  //SMALL CROSSHAIR
      Tools::Hook((void *) (uintptr_t) Il2CppGetMethodOffset("Assembly-CSharp.dll", "GameEngine","WeaponFireComponent_Instant","get_CrossHairSizeBase"), (void *) Zgcross7, (void **) &orig_Zgcross7);
	
	  Tools::Hook((void *) dlsym(RTLD_NEXT, "eglSwapBuffers"), (void *) hook_eglSwapBuffers, (void **) &old_eglSwapBuffers);
}

JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
    VM = vm;
    return JNI_VERSION_1_6;
}

__attribute__((constructor))
void lib_main() {
    pthread_t t;
	pthread_create(&t, 0, SuperThread, 0);
	std::thread(Init_Thread2).detach();
	std::thread(Init_Thread).detach();
}