main.cpp

#include "Helper/include.h"
#include "Helper/definition.h"
#include <iostream>
#include <fstream>
#include <string>
#include <curl/curl.h>
#include <dirent.h>
#include <android/asset_manager.h>
#include <android/asset_manager_jni.h>
#include <android/native_activity.h>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <sstream>
#include <openssl/sha.h>
#include <fstream>
#include <iomanip>
#include <dlfcn.h>
#include <cstddef>
#include <unwind.h>
#include <dlfcn.h>
#include <libgen.h>
#include <stdint.h>
#include <cstring>
#include <functional>
#include <unwind.h>
#include <dlfcn.h>
#include <libgen.h>
#include <stdint.h>
#include <cstring>
#include <functional>
#include <thread> 
#include <chrono>
json items_data;

// Source Made By @TheHexOp / @HexCheatsOfficial
// Join For More Cheats realated Stuffs @HexCheatsOfficial

void DrawESP(ImDrawList *draw){
draw->AddText({((float) density / 14.0f), 35}, IM_COL32(255, 255, 0, 255), "HexCheats");

auto GWorld = GetWorld();
    if (!GWorld)
    return;

    auto NetDriver = GWorld->NetDriver;
    if (!NetDriver)
    return;

    auto ServerConnection = NetDriver->ServerConnection;
    if (!ServerConnection)
    return;

    auto PlayerController = ServerConnection->PlayerController;
    if (!PlayerController)
    return;

    Cheat::localController = (ASTExtraPlayerController *)PlayerController;
    if (GWorld->PersistentLevel)
    {
    auto Actors = GetActors();
    ASTExtraPlayerCharacter *localPlayer = nullptr;
    for (int i = 0; i < Actors.size(); i++)
    {
    auto Actor = Actors[i];
    if (isObjectInvalid(Actor))
    continue;

    if (Actor->IsA(ASTExtraPlayerCharacter::StaticClass()))
    {
    if (((ASTExtraPlayerCharacter *)Actor)->PlayerKey == ((ASTExtraPlayerController *)PlayerController)->PlayerKey)
    {
    localPlayer = (ASTExtraPlayerCharacter *)Actor;
    break;
    }
    }
    }
    if (localPlayer)
    {
    Cheat::localPlayer = localPlayer;
    }
    }
// Source Made By @TheHexOp / @HexCheatsOfficial
// Join For More Cheats realated Stuffs @HexCheatsOfficial
if (Cheat::localPlayer && Cheat::localController)
{
                            if (Cheat::Aimbot::Enable)
                            {
                            draw->AddCircle(ImVec2(glWidth / 2.0f, glHeight / 2.0f), Cheat::Aimbot::Radius * 0.5f, IM_COL32(255, 255, 255, 255), 100, 0.5f);
                            }  
	                        if (Cheat::localPlayer)
                            {
                            if (Cheat::Aimbot::Enable)
                            {
                            ASTExtraPlayerCharacter *Target = GetTargetForAimBot();
                            if (Target)
                            {				
                            if (Cheat::localPlayer->bIsWeaponFiring || Cheat::localPlayer->bIsGunADS)
                            {
                            FVector targetAimPos = Target->GetBonePos("Head", {});
                            if (auto WeaponManagerComponent = Cheat::localPlayer->WeaponManagerComponent)
                            {
                            auto PropSlot = WeaponManagerComponent->GetCurrentUsingPropSlot();
                            if ((int)PropSlot.GetValue() >= 1 && (int)PropSlot.GetValue() <= 3)
                            {
                            if (auto CurrentWeaponReplicated = (ASTExtraShootWeapon *)WeaponManagerComponent->CurrentWeaponReplicated)
                            {
                            if (auto ShootWeaponComponent = CurrentWeaponReplicated->ShootWeaponComponent)
                            {
                            if (auto ShootWeaponEntityComponent = ShootWeaponComponent->ShootWeaponEntityComponent)
                            {
                            float BulletFireSpeed = CurrentWeaponReplicated->GetBulletFireSpeedFromEntity();
                            if (auto CurrentVehicle = Target->CurrentVehicle)
                            {
						    FVector LinearVelocity = CurrentVehicle->ReplicatedMovement.LinearVelocity;
							float Dist = Cheat::localPlayer->GetDistanceTo(Target);
							auto TimeToTravel = Dist / BulletFireSpeed;
							targetAimPos = targetAimPos + MultiplyVectorFloat(LinearVelocity, TimeToTravel);
							}else{
						    FVector Velocity = Target->GetVelocity();
							float dist = Cheat::localPlayer->GetDistanceTo(Target);
							auto TimeToTravel = dist / BulletFireSpeed;
							targetAimPos = targetAimPos + MultiplyVectorFloat(Velocity, TimeToTravel);
							}
                            if (Cheat::Aimbot::Enable)
                            {
                            if (Cheat::localPlayer->bIsGunADS)
                            {
                            float dist = Cheat::localPlayer->GetDistanceTo(Target) / 100.f;
                            targetAimPos.Z -= dist * Cheat::Aimbot::RecoilControl;
                            }
                            }
                            FVector gunlocation = Cheat::localController->PlayerCameraManager->CameraCache.POV.Location;
                            FRotator aimrotation = ToRotator(gunlocation, targetAimPos);
                            FRotator gunrotaton = Cheat::localController->PlayerCameraManager->CameraCache.POV.Rotation;
                            aimrotation.Pitch -= gunrotaton.Pitch;
                            aimrotation.Yaw -= gunrotaton.Yaw;
                            aimrotation.Roll = 0.0f;
                            clampAngles(aimrotation);
                            gunrotaton.Pitch += aimrotation.Pitch / 4.0f;
                            gunrotaton.Yaw += aimrotation.Yaw / 4.0f;
                            gunrotaton.Roll = 0.0f;                                        
                            Cheat::localController->SetControlRotation(gunrotaton, "");
                            }
							}
							}
							}
							}
							}
							}
							}
							}
							}                                                                                                                                                                  
if (Cheat::localPlayer && Cheat::localController)
{
	                     	int totalEnemies = 0, totalBots = 0;
                            auto Actors = GetActors();
                            for (auto &Actor : Actors)
                            {
                            if (isObjectInvalid(Actor))
                            continue;
                            if (Actor->IsA(ASTExtraPlayerCharacter::StaticClass())) {
                            ImU32 PlayerBone;
                            ImU32 PlayerLine;
                            ImU32 BotLine;
                            ImU32 BotBone;
                            ImU32 PlayerAlert;
                            ImU32 BotAlert;
                            auto Player = (ASTExtraPlayerCharacter *) Actor;
                            bool IsVisible = Cheat::localController->LineOfSightTo(Player, {0, 0, 0},
                            true);
                            if (IsVisible) {
                            BotBone = IM_COL32(251, 251, 251, 251);
                            PlayerBone = IM_COL32(51, 238, 238, 255);
                            PlayerLine = IM_COL32(51, 238, 238, 255);
                            BotLine = IM_COL32(251, 251, 251, 251);
                            } else {
                            BotBone = IM_COL32(0, 0, 0, 255);
                            PlayerBone = IM_COL32(169, 18, 18, 255);
                            PlayerLine = IM_COL32(110, 92, 116, 255);
                            BotLine = IM_COL32(119, 136, 153, 255);
                            }
                            float Distance = Cheat::localPlayer->GetDistanceTo(Player) / 100.0f;                          
                            if (Distance > 500.0f)                            
                            continue;                                                       
                            if (Player->PlayerKey == Cheat::localController->PlayerKey)                            
                            continue;                        
                            if (Player->TeamID == Cheat::localController->TeamID || Player->bDead || !Player->Mesh || Player->bHidden)                            
                            continue;                                                                                                       
                            if (Player->bEnsure)
                            totalBots++;
                            else
                            totalEnemies++;                                                                   
                            float magic_number = (Distance);
                            float mx = (glWidth / 4) / magic_number;

                            float healthLength = glWidth / 17;
                            if (healthLength < mx)
                            healthLength = mx;
                            auto HeadPos = Player->GetBonePos("Head", {});
                            HeadPos.Z = HeadPos.Z + 35.0f;
                            ImVec2 headPosSC;

                            auto SexPos = Player->GetBonePos("Head", {});
                            SexPos.Z = SexPos.Z + 1.0f;
                            ImVec2 SexPosc;

                            auto RootPos = Player->GetBonePos("Root", {});
                            ImVec2 RootPosSC;
                            TargetPos = HeadPos;

                            if (W2S(HeadPos, (FVector2D * ) & headPosSC) && W2S(RootPos, (FVector2D * ) & RootPosSC)) {

                            if (Cheat::Esp::Line) {
                            draw->AddLine({(float) glWidth / 2, 0}, headPosSC,BotBone, 2.5f);
                            }
                            
						    if (Cheat::Esp::Box) {
                            float boxHeight = abs(headPosSC.y - RootPosSC.y);
                            float boxWidth = boxHeight * 0.65f;
                            Box4Line(draw, 0.5f, headPosSC.x - (boxWidth / 2), headPosSC.y, boxWidth, boxHeight,  BotBone);
                            }
                            
                            if (Cheat::Esp::WeaponName)
                            {
                            std::string weaponname;
                            weaponname += "Fist";
                            if (auto WeaponManagerComponent = Player->
                            WeaponManagerComponent)
                            {
                            auto PropSlot = WeaponManagerComponent->
                            GetCurrentUsingPropSlot();

                            if ((int)PropSlot.GetValue() >= 1 && (int)PropSlot.
                            GetValue() <= 3)
                            {
                            if (auto CurrentWeaponReplicated = 
                            WeaponManagerComponent->CurrentWeaponReplicated)
                            {
                            weaponname = CurrentWeaponReplicated->
                            GetWeaponName().ToString();
                            }
                            }
                            }
                            auto weaponTextSize = ImGui::CalcTextSize2(weaponname.
                            c_str(), 0, 18.0f);

                            FVector2D startxt(headPosSC.x - (weaponTextSize.x / 2), 
                            headPosSC.y - 40.0f);

                            DrawTextWithBorder(draw, weaponname, startxt, 
                            IM_COL32(255, 0, 0, 255), outlinecolor, 18.0f);
                            }
                            
                            if (Cheat::Esp::Skeleton) {
                            static std::vector <std::string> right_arm{"neck_01",
                            "clavicle_r","upperarm_r","lowerarm_r","hand_r", "item_r"};
                            static std::vector <std::string> left_arm{"neck_01",
                            "clavicle_l","upperarm_l","lowerarm_l","hand_l", "item_l"};
                            static std::vector <std::string> spine{"Head", "neck_01",
                            "spine_03", "spine_02","spine_01", "pelvis"};
                            static std::vector <std::string> lower_right{"pelvis",
                            "thigh_r","calf_r","foot_r"};
                            static std::vector <std::string> lower_left{"pelvis", "thigh_l",
                            "calf_l", "foot_l"};
                            static std::vector <std::vector<std::string>> skeleton{
                            right_arm, left_arm, spine, lower_right, lower_left};
                            for (auto &boneStructure: skeleton) {
                            std::string lastBone;
                            for (std::string &currentBone: boneStructure) {
                            if (!lastBone.empty()) {
                            ImVec2 boneFrom, boneTo;
                            if (W2S(Player->GetBonePos(lastBone.c_str(), {}),
                            (FVector2D * ) & boneFrom) &&
                            W2S(Player->GetBonePos(currentBone.c_str(), {}),
                            (FVector2D * ) & boneTo)) {
                            if (Player->bEnsure) {
                            draw->AddLine(boneFrom, boneTo, BotBone, 2.5f);
                            } else {
                            draw->AddLine(boneFrom, boneTo, PlayerBone, 2.5f);
                            }
                            }
                            }
                            lastBone = currentBone;
                            }
                            }
                            ImVec2 headPos;
                            if (W2S(Player->GetBonePos("Head", {}),
                            (FVector2D * ) & headPos)) {
                            float radius = 6.f - Distance * 0.03;

                            if (Player->bEnsure) {
                            draw->AddCircle(headPos, radius, BotBone, 12, 3.0f);
                            } else {
                            draw->AddCircle(headPos, radius, PlayerBone, 12, 3.0f);
                            }
                            }
                            }
                            
                            if (Cheat::Esp::Health)
                            {
                            int CurHP = (int)std::max(0, std::min((int)Player->Health, (int)Player->HealthMax));
                            int MaxHP = (int)Player->HealthMax;
                            ImU32 color_red = ImColor(255, 25, 25);
                            ImU32 color_orange = ImColor(255, 180, 0);
                            ImU32 color_Cyan = ImColor(255, 255, 255);
                            ImU32 current_color = color_Cyan;
                            float health = Player->Health;

                            if (health <= 50.0f) {
                            current_color = color_orange;
                            }                            
                            if (health <= 25.0f) {
                            current_color = color_red;
                            }
                            float boxHeight = abs(headPosSC.y - RootPosSC.y);
                            float boxWidth = 5.0f;
                            ImVec2 vStart = {headPosSC.x + 15.0f + (boxWidth / 2), headPosSC.y};
                            ImVec2 vEnd = {vStart.x + boxWidth, vStart.y + boxHeight};                        
                            ImVec2 vEndFilled = {vStart.x + (CurHP * boxWidth / MaxHP),
                            vStart.y + boxHeight};
                            ImVec2 vEndRect = {vStart.x + boxWidth, vStart.y + boxHeight};
                            draw->AddRectFilled(vStart, vEndFilled, current_color);
                            }
						    }
						    
						    if (Cheat::Esp::Name || Cheat::Esp::Distance) {
                            ImGuiStyle &style = ImGui::GetStyle();
                            ImVec4 savedTextColor = style.Colors[ImGuiCol_Text];
                            style.Colors[ImGuiCol_Text] = ImVec4(1.0f, 1.0f, 1.0f, 1.0f);

                            std::string nameText;
                            std::string distanceText;
                            if (Cheat::Esp::Name) {
                            nameText += Player->bEnsure ? "bot" : Player->PlayerName.ToString();
                            }
                            
                            if (Cheat::Esp::Distance) {
                            distanceText += (!nameText.empty() ? "  " : "") +
						    std::to_string(static_cast<int>(Distance)) + "M";
                            }
                            
                            auto drawTextWithStroke = [&](const std::string &text, const ImVec2 &position, ImU32 color) {
                            float strokeSize = 0.5f;
                            for (float x = -strokeSize; x <= strokeSize; x += strokeSize) {
                            for (float y = -strokeSize; y <= strokeSize; y += strokeSize) {
                            draw->AddText(NULL, ((float) density / 22.0f), {position.x + x, position.y + y}, IM_COL32(0, 0, 0, 255), text.c_str());
                            }
                            }
                            draw->AddText(NULL, ((float) density / 22.0f), position, color, text.c_str());
                            };
                            auto textSize = ImGui::CalcTextSize2(nameText.c_str(), 0, ((float) density / 28.0f));
                            auto distanceTextSize = ImGui::CalcTextSize2(distanceText.c_str(), 0, ((float) density / 28.0f));
                            drawTextWithStroke(nameText, {RootPosSC.x - (textSize.x / 2), RootPosSC.y}, IM_COL32(56, 200, 203, 245));
                            drawTextWithStroke(distanceText, {RootPosSC.x - (distanceTextSize.x / 2), RootPosSC.y + 18}, IM_COL32(255, 255, 255, 255));
                            style.Colors[ImGuiCol_Text] = savedTextColor;
                            }
					        }
					        
                            if (Cheat::Esp::Vehicle::Name)
                            {
						    if (Actor->IsA(ASTExtraVehicleBase::StaticClass())) {
                            auto Vehicle = (ASTExtraVehicleBase *) Actor;
                            if (!Vehicle->Mesh)
                            continue;

                            float Distance = Vehicle->GetDistanceTo(Cheat::localPlayer) / 100.f;

                            FVector2D vehiclePos;
                            if (W2S(Vehicle->K2_GetActorLocation(), &vehiclePos)) {
                            std::string s = GetVehicleName(Vehicle);
                            if (Cheat::Esp::Vehicle::Name) {
                            s += " [";
                            s += std::to_string((int) Distance);
                            s += "m]";
                            }
                            draw->AddText(NULL, ((float) density / 20.0f), {vehiclePos.X, vehiclePos.Y}, IM_COL32(255, 255, 0, 255), s.c_str());
                            }
                            }
                            }
							}

                    if (totalEnemies > 0 || totalBots > 0) {
                    std::string s;
                    if (totalEnemies + totalBots > 0) {
                    s = std::to_string((int)totalEnemies + totalBots);
                    } else {
                    s += "0";
                    }
                    auto textSize = ImGui::CalcTextSize2(s.c_str(), 0, ((float)density / 15.5f));
                    draw->AddText(NULL, ((float)density / 10.5f), {((float)glWidth / 2) - (textSize.x / 2), 50}, IM_COL32_BLACK, s.c_str());
                    draw->AddText(NULL, ((float)density / 10.5f), {((float)glWidth / 2) - (textSize.x / 2) + 1, 50 + 1}, IM_COL32_BLACK, s.c_str()); 
                    draw->AddText(NULL, ((float)density / 10.5f), {((float)glWidth / 2) - (textSize.x / 2) - 1, 50 - 1}, IM_COL32_BLACK, s.c_str()); 
                    draw->AddText(NULL, ((float)density / 10.5f), {((float)glWidth / 2) - (textSize.x / 2), 50}, IM_COL32(255, 6, 6, 255), s.c_str());
					}
					}
					}

// Source Made By @TheHexOp / @HexCheatsOfficial
// Join For More Cheats realated Stuffs @HexCheatsOfficial

EGLBoolean (*orig_eglSwapBuffers)(EGLDisplay dpy, EGLSurface surface);
EGLBoolean _eglSwapBuffers(EGLDisplay dpy, EGLSurface surface){
    eglQuerySurface(dpy, surface, EGL_WIDTH, &glWidth);
    eglQuerySurface(dpy, surface, EGL_HEIGHT, &glHeight);
    screenWidth = ANativeWindow_getWidth(g_App->window);
    screenHeight = ANativeWindow_getHeight(g_App->window);
    density = AConfiguration_getDensity(g_App->config);
    if (!initImGui)
    {
    ImGui::CreateContext();
    ImGuiStyle &style = ImGui::GetStyle();
    ImGui::StyleColorsDark();
    ImGui_ImplAndroid_Init();
    ImGui_ImplOpenGL3_Init(OBFUSCATE("#version 300 es"));
    ImGuiIO &io = ImGui::GetIO();
	static const ImWchar icons_ranges[] = {0xf000, 0xf3ff, 0};
    ImFontConfig icons_config;
    ImFontConfig CustomFont;	
    io.Fonts->AddFontFromMemoryTTF(const_cast<std::uint8_t*>(Custom), sizeof(Custom), 18.f, &CustomFont);
    io.Fonts->AddFontFromMemoryCompressedTTF(font_awesome_data, font_awesome_size, 16.0f, &icons_config, icons_ranges);	       
    ImFontConfig cfg;
    cfg.SizePixels = ((float) density / 20.0f);
    io.Fonts->AddFontDefault(&cfg);    
    initImGui = true;
    }
    ImGuiIO &io = ImGui::GetIO();
    ImGui_ImplOpenGL3_NewFrame();
    ImGui_ImplAndroid_NewFrame(glWidth, glHeight);
    ImGui::NewFrame();

   DrawESP(ImGui::GetBackgroundDrawList());

    ImGui::SetNextWindowSize({712, 600});
    static auto FlagsOne = ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar;

    if (ImGui::Begin(("HEX"), 0, FlagsOne))
    {

		        /* static bool isLogin = false, logginIn = false;
                 static std::string err;
                 if (!isLogin) {
                 ImGui::Text("Welcome To Vip Login");
                 ImGui::PushItemWidth(-1);
                 static char s[64];
                 ImGui::InputText("##key", s, sizeof s);
                 auto key = getClipboardText();
                 strncpy(s, key.c_str(), sizeof s);
                 err = Login(s);
                 if (err == "OK") {
                 isLogin = bValid && g_Auth == g_Token;
                 }
                 ImGui::PopItemWidth();
                 ImGui::PushItemWidth(-1);
                 if (ImGui::Button(" Paste Your Key  ", ImVec2(ImGui::GetContentRegionAvailWidth(), 0))) {
                 auto key = getClipboardText();
                 strncpy(s, key.c_str(), sizeof s);
                 }
                 ImGui::PopItemWidth();
                 ImGui::PushItemWidth(-1);
                 if (ImGui::Button(" Tap To Login ", ImVec2(ImGui::GetContentRegionAvailWidth(), 0))) {
                 err = Login(s);
                 if (err == "OK") {
                 isLogin = bValid && g_Auth == g_Token;
                 }
                 }
                 ImGui::PopItemWidth();
                 if (!err.empty() && err != "OK") {
                 ImGui::Text("Error: %s", err.c_str());
                 }
                 ImGui::PopItemWidth();
                 } else{
			     if (!g_Token.empty() && !g_Auth.empty() && g_Token == g_Auth) {  
	           	 if (!g_Token.empty() && !g_Auth.empty() && g_Token == g_Auth) {*/
		         Cheat::Esp::Name = true;
	             Cheat::Esp::Line = true;
		         Cheat::Esp::Box = false;
		         Cheat::Esp::Health = true;
		         Cheat::Esp::Distance = true;
		         Cheat::Esp::WeaponName = true;
                 Cheat::Esp::Skeleton = true;
                 Cheat::Esp::LootBox = true;
                 Cheat::Esp::Vehicle::Name = true;
                 
                 Cheat::Aimbot::Enable = true;
                 Cheat::Aimbot::VisCheck = true;
                 Cheat::Aimbot::IgnoreKnock = true;
                 Cheat::Aimbot::RecoilControl = 1.250f;
                 Cheat::Aimbot::Radius = 400.0f;
                 Cheat::Aimbot::Range = 200.0f;
                 }
       	        // }
       	        // }
       	        // }
                 ImGui::End();
                 ImGui::Render();
                 ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
                 return orig_eglSwapBuffers(dpy, surface);
                 }
    uintptr_t getBase(pid_t pid){
    FILE *fp;
    uintptr_t addr = 0;
    char filename[40], buffer[1024];
    snprintf(filename, sizeof(filename), "/proc/%d/maps", pid);
    fp = fopen(filename, "rt");
    if (fp != NULL)
    {
    while (fgets(buffer, sizeof(buffer), fp))
    {
    if (strstr(buffer, "libUE4.so"))
    {
    addr = (uintptr_t)strtoul(buffer, NULL, 16);
    break;
    }
    }
    fclose(fp);
    }
    return addr;
    }
// Source Made By @TheHexOp / @HexCheatsOfficial
// Join For More Cheats realated Stuffs @HexCheatsOfficial
    void FixGameCrash(){
    system("rm -rf /data/data/com.pubg.imobile/files");
    system("rm -rf /data/data/com.pubg.imobile/files/ano_tmp");
    system("touch /data/data/com.pubg.imobile/files/ano_tmp");
    system("chmod 000 /data/data/com.pubg.imobile/files/ano_tmp");
    system("rm -rf /data/data/com.pubg.imobile/files/obblib");
    system("touch /data/data/com.pubg.imobile/files/obblib");
    system("chmod 000 /data/data/com.pubg.imobile/files/obblib");
    system("rm -rf /data/data/com.pubg.imobile/files/xlog");
    system("touch /data/data/com.pubg.imobile/files/xlog");
    system("chmod 000 /data/data/com.pubg.imobile/files/xlog");
    system("rm -rf /data/data/com.pubg.imobile/app_bugly");
    system("touch /data/data/com.pubg.imobile/app_bugly");
    system("chmod 000 /data/data/com.pubg.imobile/app_bugly");
    system("rm -rf /data/data/com.pubg.imobile/app_crashrecord");
    system("touch /data/data/com.pubg.imobile/app_crashrecord");
    system("chmod 000 /data/data/com.pubg.imobile/app_crashrecord");
    system("rm -rf /data/data/com.pubg.imobile/app_crashSight");
    system("touch /data/data/com.pubg.imobile/app_crashSight");
    system("chmod 000 /data/data/com.pubg.imobile/app_crashSight");
    }
	void *hack_thread(void *) {
    auto ANOGS = Tools::GetBaseAddress("libanogs.so");
    while (!ANOGS) {
    ANOGS = Tools::GetBaseAddress("libanogs.so");
    sleep(1);
    }
    do {
    sleep(1);
    } while (!isLibraryLoaded("libanogs.so"));
   // Your Bypass
    return NULL;
}
    void *main_thread(void *)
    {
    FixGameCrash();
    pid_t Pid = getpid();
    Cheat::libUE4Base = getBase(Pid);
    while (!Cheat::libUE4Base)
    {
    Cheat::libUE4Base = getBase(Pid);
    sleep(1);
    }
    while (!g_App)
    {
    g_App = *(android_app **)(Cheat::libUE4Base + Cheat::GNativeAndroidApp_Offset);
    sleep(1);
    }
    FName::GNames = GetGNames();
    while (!FName::GNames)
    {
    FName::GNames = GetGNames();
    sleep(1);
    }
    UObject::GUObjectArray = (FUObjectArray *)(Cheat::libUE4Base + Cheat::GUObject_Offset);
    Tools::Hook((void *) DobbySymbolResolver(OBFUSCATE("/system/lib/libEGL.so"), OBFUSCATE("eglSwapBuffers")), (void *) _eglSwapBuffers, (void **) &orig_eglSwapBuffers);
    items_data = json::parse(JSON_ITEMS);
    return nullptr;
    }
    __attribute__((constructor)) void _init(){
    pthread_create(&t, NULL, main_thread, NULL);
	pthread_create(&t, NULL, hack_thread, NULL);
    }
// Source Made By @TheHexOp / @HexCheatsOfficial
// Join For More Cheats realated Stuffs @HexCheatsOfficial