v0.2

README.md

@@ -2,26 +2,23 @@
 #####  UnknownCheats thread: https://www.unknowncheats.me/forum/apex-legends/406426-kvm-vmread-apex-esp-aimbot.html
 #new features
 
-- Xp level ESP
+-  Xp Level ESP
--  seerhealthESP/smooth aimbot from https://kgithub.com/KrackerCo/apex_dma_kvm_pub.
+-  seerhealthESP/some aimbot code,paste from https://github.com/KrackerCo/apex_dma_kvm_pub.
--  platform userid ESP,i also keep one html file,you can input uid to search player's rank,selcet legend.
+-  platform userid ESP,use it to search player's rank'.
-> idont know why after i add rank ESP,the client will crash,but i keep void"GetJson", these code are paste from https://www.unknowncheats.me/forum/apex-legends/520061-rank-statistics-players.html,
+> idont know why after add rank ESP,the client will crash,but i keep void"GetJson", these code are paste from https://www.unknowncheats.me/forum/apex-legends/520061-rank-statistics-players.html,
-if somebody can finish this work, +pull request please
+   if someone can finish it, + pull request please
--  support UTF-8 ESP for japanese/chinese
+-  support UTF-8 ESP for japanese and chinese
 -  free camera
--  client's stream proof,include commandline,you can change it to view offset in client's main.cpp 
+-  overlay's steam proof by setwindowdisplaffinity
-    void ShowWindow
+-  client's stream proof,(hide commandline),check it  in client : main.cpp (void ShowWindow)
 - you can enable aimbot/esp for your teammates
+- press mouse4 to disable visible check
 # how to use
 ## guest
--   use vmprotect or rewrite your own version
+-  to bypass EAC detection,use ctrl+h to replace "serial-string" to anything you want.
 -  release x64, use custom overlay.
 ## linux
- - install 'libcurl' and 'jsoncpp',if cant complie ,check the Makefile
+ - change no-recoil strength in Game.cpp
-####  Archlinux
+ - for rank esp, you need your own apikey,reg one from apexlegendsapi, use index.html ,input userid to search player's rank
-`    sudo  pacman -S jsoncpp`
+ -  what's "add_off"?  ,it's in apex_dma.cpp , will display in client's commandline
-`    sudo  pacman -S curl`
- - for rank esp, you need your own apikey,reg one from apexlegendsapi
- -  what's "add_off"?  , host need it to read the setting of guest,it's in apex_dma.cpp
- 
 * i have no time to  teach about GPU passthrough or how to install this repo, because i only have a few time .....sorry of that*

apex_dma/Game.cpp

@@ -340,7 +340,7 @@ float CalculateFov(Entity& from, Entity& target)
 	return Math::GetFov(ViewAngles, Angle);
 }
 
-QAngle CalculateBestBoneAim(Entity& from, uintptr_t t, float max_fov , int recoil_val)
+QAngle CalculateBestBoneAim(Entity& from, uintptr_t t, float max_fov)
 {
 	Entity target = getEntity(t);
 	if (firing_range)
@@ -423,9 +423,9 @@ QAngle CalculateBestBoneAim(Entity& from, uintptr_t t, float max_fov , int recoi
 	//remove sway and recoil
 	if (aim_no_recoil) {
 		QAngle sway = SwayAngles - ViewAngles;
-                sway.x = sway.x * recoil_val;   //pitch
+		sway.x = sway.x * 0.8;   //pitch
-                sway.y = sway.y * recoil_val;  //yaw
+		sway.y = sway.y * 0.75;  //yaw
-                sway.z = sway.z * recoil_val;
+		sway.z = sway.z * 0.9;
 		CalculatedAngles -= sway;
 	}
 	Math::NormalizeAngles(CalculatedAngles);
@@ -439,21 +439,21 @@ QAngle CalculateBestBoneAim(Entity& from, uintptr_t t, float max_fov , int recoi
 	Math::NormalizeAngles(Delta);
 
 	QAngle RandomAngles = QAngle(
-        (rand() % 5 - 4) * 0.001f,
+		(rand() % 4 - 2) * 0.001f,
-        (rand() % 5 - 4) * 0.001f,
+		(rand() % 4 - 2) * 0.001f,
-        (rand() % 5 - 4) * 0.001f
+		(rand() % 4 - 2) * 0.001f
 	);
 	QAngle RandomAnglesMax = QAngle(
-        (rand() % 8 - 4) * 0.001f,
+		(rand() % 6 - 2) * 0.001f,
-        (rand() % 8 - 4) * 0.001f,
+		(rand() % 6 - 2) * 0.001f,
-        (rand() % 8 - 4) * 0.001f
+		(rand() % 6 - 2) * 0.001f
 	);
 	miss = rand() % 100;
 	QAngle SmoothedAngles = ViewAngles + Delta / smooth + RandomAngles;
-        if(miss >= 60){
+	if (miss >= 70) {
 		QAngle SmoothedAngles = ViewAngles + Delta / smooth + RandomAnglesMax;
 	}
-        else if(miss <= 50){
+	else {
 		QAngle SmoothedAngles = ViewAngles + Delta / smooth + RandomAngles;
 	}
 

apex_dma/Game.h

@@ -94,7 +94,7 @@ Entity getEntity(uintptr_t ptr);
 Item getItem(uintptr_t ptr);
 bool WorldToScreen(Vector from, float* m_vMatrix, int targetWidth, int targetHeight, Vector& to);
 float CalculateFov(Entity& from, Entity& target);
-QAngle CalculateBestBoneAim(Entity& from, uintptr_t target, float max_fov , int recoil_val);
+QAngle CalculateBestBoneAim(Entity& from, uintptr_t target, float max_fov);
 void get_class_name(uint64_t entity_ptr, char* out_str);
 void charge_rifle_hack(uint64_t entity_ptr);
 

apex_dma/Makefile

@@ -1,6 +1,6 @@
 CXX=g++
 CXXFLAGS=-I./memflow_lib/memflow-win32-ffi/ -I./memflow_lib/memflow-ffi/ -L./memflow_lib/target/release -Wno-multichar
-LIBS=-lm -Wl,--no-as-needed -ldl -lpthread -l:libmemflow_win32_ffi.a -lcurl -l:libjsoncpp.so
+LIBS=-lm -Wl,--no-as-needed -ldl -lpthread -l:libmemflow_win32_ffi.a
 
 OUTDIR=./build
 OBJDIR=$(OUTDIR)/obj

apex_dma/Readme.md

@@ -1,27 +0,0 @@
-#  apex_dma_kvm_pub
-#####  UnknownCheats thread: https://www.unknowncheats.me/forum/apex-legends/406426-kvm-vmread-apex-esp-aimbot.html
-#new features
-
-- Xp level ESP
--  seerhealthESP/smooth aimbot from https://kgithub.com/KrackerCo/apex_dma_kvm_pub.
--  platform userid ESP,i also keep one html file,you can input uid to search player's rank,selcet legend.
-> idont know why after i add rank ESP,the client will crash,but i keep void"GetJson", these code are paste from https://www.unknowncheats.me/forum/apex-legends/520061-rank-statistics-players.html,
-if somebody can finish this work, +pull request please
--  support UTF-8 ESP for japanese/chinese
--   free camera
--  client's stream proof,include commandline,you can change it to view offset in client's main.cpp 
-    void ShowWindow
-- you can enable aimbot/esp for your teammates
-# how to use
-## guest
--   use vmprotect or rewrite your own version
--  release x64, use custom overlay.
-## linux
- - install 'libcurl' and 'jsoncpp',if cant complie ,check the Makefile
-####  Archlinux
-`    sudo  pacman -S jsoncpp`
-`    sudo  pacman -S curl`
- - for rank esp, you need your own apikey,reg one from apexlegendsapi
- -  what's "add_off"?  , host need it to read the setting of guest,it's in apex_dma.cpp
- 
-* i have no time to  teach about GPU passthrough or how to install this repo, because i only have a few time .....sorry of that*

apex_dma/apex_dma.cpp

@@ -5,8 +5,6 @@
 #include <random>
 #include <chrono>
 #include <iostream>
-#include "json/json.h"
-#include "curl/curl.h"
 #include <cfloat>
 #include "Game.h"
 #include <thread>
@@ -14,12 +12,11 @@
 Memory apex_mem;
 Memory client_mem;
 
-uint64_t add_off = 0x411e0;
+uint64_t add_off = 0xa1040;
 
 bool freecam = false;
 bool lockall_enable = false;
 
-int recoil = 0.5;
 bool firing_range = false;
 bool active = true;
 uintptr_t aimentity = 0;
@@ -84,28 +81,6 @@ int tmp_all_spec = 0, allied_spectators = 0;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
-static size_t WriteCallback(void *contents, size_t size, size_t nmemb, void *userp)
-{
-    ((std::string *)userp)->append((char *)contents, size * nmemb);
-    return size * nmemb;
-}
-std::string getJson(std::string url)
-{
-    CURL *curl;
-    CURLcode res;
-    std::string readBuffer;
-    curl = curl_easy_init();
-    if (curl)
-    {
-        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
-        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
-        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
-        res = curl_easy_perform(curl);
-        curl_easy_cleanup(curl);
-    }
-    return readBuffer;
-}
-
 void ProcessPlayer(Entity& LPlayer, Entity& target, uint64_t entitylist, int index)
 {
 	int entity_team = target.getTeamId();
@@ -192,36 +167,6 @@ void DoActions()
 
 			uint64_t entitylist = g_Base + OFFSET_ENTITYLIST;
 
-
-			//an model index dumper,but sometimecarsh game
-			/*
-			uint64_t viewmodel_handle = 0;
-			apex_mem.Read<uint64_t>(LocalPlayer + 0x2d78, viewmodel_handle);
-			viewmodel_handle &= 0xffff;
-			uint64_t viewmodel_entity = 0;
-			apex_mem.Read<uint64_t>(entitylist + (viewmodel_handle << 5), viewmodel_entity);
-				m_currentFrame.modelIndex=0x00a8
-				m_hViewModels=0x2d78
-				m_ModelName=0x00a8
-			apex_mem.Write<int>(viewmodel_entity + 0x00a8, 975);
-
-			index dumper
-				bool dump_loop = false;
-				if(model_index <= 2492 && dump_loop){
-					uint64_t name_ptr;
-					char ModelName[200] = { 0 };
-					model_index = model_index + 1;
-					apex_mem.Read<uint64_t>(viewmodel_entity + 0x0030, name_ptr); 
-					apex_mem.ReadArray<char>(name_ptr, ModelName, 200);
-					printf("model: %s , index: %u \n", ModelName,model_index);
-					if (strstr(ModelName, "mdl/Weapons/arms/pov_pilot_light_wraith_cyber_ninja.rmdl")) 
-					{
-						printf("%u\n", model_index);
-						dump_loop = false;
-					}
-				}
-			}			
-			*/
 			uint64_t baseent = 0;
 			apex_mem.Read<uint64_t>(entitylist, baseent);
 			if (baseent == 0)
@@ -440,7 +385,6 @@ static void EspLoop()
 							int xp_level = calc_level(xp);
 							uint64_t uid = 0;
 							apex_mem.Read<uint64_t>(centity + OFFSET_UID, uid);
-							
 							players[c] =
 							{
 								dist,
@@ -596,7 +540,7 @@ static void AimbotLoop()
 				apex_mem.Read<uint64_t>(g_Base + OFFSET_LOCAL_ENT, LocalPlayer);
 				if (LocalPlayer == 0) continue;
 				Entity LPlayer = getEntity(LocalPlayer);
-				QAngle Angles = CalculateBestBoneAim(LPlayer, aimentity, max_fov, recoil);
+				QAngle Angles = CalculateBestBoneAim(LPlayer, aimentity, max_fov);
 				if (Angles.x == 0 && Angles.y == 0)
 				{
 					klock = false;
@@ -661,8 +605,6 @@ static void set_vars(uint64_t add_addr)
 	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 21, lockall_addr);
 	uint64_t firing_range_addr = 0;
 	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 22, firing_range_addr);
-	uint64_t recoil_addr=0;
-        client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t)*23, recoil_addr);
 
 	uint32_t check = 0;
 	client_mem.Read<uint32_t>(check_addr, check);
@@ -704,7 +646,7 @@ static void set_vars(uint64_t add_addr)
 			client_mem.Read<bool>(freecam_addr, freecam);
 			client_mem.Read<bool>(lockall_addr, lockall_enable);
 			client_mem.Read<bool>(firing_range_addr, firing_range);
-			client_mem.Read<int>(recoil_addr, recoil);
+
 			if (esp && knext)
 			{
 				if (valid)

apex_dma/offsets.h

@@ -8,7 +8,7 @@
 #define OFFSET_WEAPON_NAME          0x1858 //m_weaponNameIndex 2nd one
 #define OFFSET_ENTITYLIST		0x1e53c68 //cl_entitylist
 #define OFFSET_LOCAL_ENT		0x22036C0 + 0x8 //.?AVC_GameMovement@@ + 0x8
-#define OFFSET_NAME_LIST            0xbe94be0 //NameList
+#define OFFSET_NAME_LIST            0xbe94b60 //NameList
 
 #define OFFSET_TEAM					0x044c //m_iTeamNum
 #define OFFSET_HEALTH				0x043c //m_iHealth
@@ -34,7 +34,7 @@
 #define OFFSET_OBSERVING_TARGET		0x3500 //m_hObserverTarget
 
 #define OFFSET_MATRIX				0x11a350 //ViewMatrix
-#define OFFSET_RENDER				0x743AB20 //ViewRender
+#define OFFSET_RENDER				0x743AAA0 //ViewRender
 
 #define OFFSET_BULLET_SPEED         0x1f3c
 #define OFFSET_BULLET_SCALE         0x1f44

apex_guest/Client/Client/main.cpp

@@ -1,143 +1,209 @@
 #include "main.h"
 
-typedef struct player
+typedef struct serial - stringplayer
-{
+{
-	float dist = 0;
+	float serial - stringdist = 0;
-	int entity_team = 0;
+	int serial - stringentity_team = 0;
-	float boxMiddle = 0;
+	float serial - stringboxMiddle = 0;
-	float h_y = 0;
+	float serial - stringh_y = 0;
-	float width = 0;
+	float serial - stringwidth = 0;
-	float height = 0;
+	float serial - stringheight = 0;
-	float b_x = 0;
+	float serial - stringb_x = 0;
-	float b_y = 0;
+	float serial - stringb_y = 0;
-	bool knocked = false;
+	bool serial - stringknocked = false;
-	bool visible = false;
+	bool serial - stringvisible = false;
-	int health = 0;
+	int serial - stringhealth = 0;
-	int shield = 0;
+	int serial - stringshield = 0;
-	int xp_level = 0;
+	int serial - stringxp_level = 0;
-	int maxshield = 0;
+	int serial - stringmaxshield = 0;
-	int armortype = 0;
+	int serial - stringarmortype = 0;
-	uint64_t uid = 0;
+	uint64_t serial - stringuid = 0;
-	char name[33] = { 0 };
+	char serial - stringname[33] = { 0 };
-}player;
+}serial - stringplayer;
- 
+
-uint32_t check = 0xABCD;
+typedef struct serial - stringrankinfomation
+{
+	char rankserial - stringinfo[17];
+}serial - stringrankinfomation;
+
+uint32_t serial - stringcheck = 0xABCD;
 //VK_XBUTTON2=<3D>ϲ<EFBFBD><CFB2> //VK_XBUTTON1 = <20>²<EFBFBD><C2B2>
-int aim_key = VK_XBUTTON2;
+int serial - stringaim_key = VK_XBUTTON2;
-int aim_key2 = VK_XBUTTON1;
+int serial - stringaim_key2 = VK_XBUTTON1;
-
+
-int shoot_key = VK_LBUTTON;
+int serial - stringshoot_key = VK_LBUTTON;
-
+
-float scale = 1.4f;
+float serial - stringscale = 1.4f;
-bool firing_range;
+bool serial - stringfiring_range;
-int offset = 0;
+int serial - stringoffset = 0;
-bool use_nvidia = false;
+bool serial - stringuse_nvidia = false;
-bool active = true;
+bool serial - stringactive = true;
-bool ready = false;
+bool serial - stringready = false;
-extern visuals v;
+extern serial - stringvisuals serial - stringv;
-int aim = 2; //read
+int serial - stringaim = 2; //read
-
+
-bool freecam = false;//read
+float serial - stringuid_dist = 150.0f * 40.0f;
-bool lockall_mode = false; //read
+float serial - stringname_dist = 150.0f * 40.0f;
-
+bool serial - stringfreecam = false;//read
-int recoil_100 = 75;
+bool serial - stringlockall_mode = false; //read
-int recoil = 0.5;
+
-bool esp = true; //read
+bool serial - stringesp = true; //read
-bool item_glow = false;
+bool serial - stringitem_glow = false;
-bool player_glow = false;
+bool serial - stringplayer_glow = false;
-bool aim_no_recoil = true;
+bool serial - stringaim_no_recoil = true;
-bool aiming = false; //read
+bool serial - stringaiming = false; //read
-uint64_t g_Base = 0; //write
+uint64_t serial - stringg_Base = 0; //write
-float max_dist = 650.0f * 40.0f; //read
+float serial - stringmax_dist = 650.0f * 40.0f; //read
-float seer_dist = 400.0 * 40.0f;
+float serial - stringseer_dist = 400.0 * 40.0f;
-float smooth = 85.0f;
+float serial - stringsmooth = 77.0f;
-float max_fov = 20.0f;
+float serial - stringmax_fov = 20.0f;
-int bone = 3;
+int serial - stringbone = 3;
-bool thirdperson = false;
+bool serial - stringthirdperson = false;
-int spectators = 0; //write
+int serial - stringspectators = 0; //write
-int allied_spectators = 0; //write
+int serial - stringallied_spectators = 0; //write
-bool chargerifle = false;
+bool serial - stringchargerifle = false;
-bool shooting = false; //read
+bool serial - stringshooting = false; //read
-
+
-
+
-int index = 0;
+int serial - stringindex = 0;
-bool valid = false; //write
+bool serial - stringvalid = false; //write
-bool next = false; //read write
+bool serial - stringnext = false; //read write
-
+
-uint64_t add[24];
+uint64_t serial - stringadd[23];
-
+
-bool k_f5 = 0;
+bool serial - stringk_f5 = 0;
-bool k_f6 = 0;
+bool serial - stringk_f6 = 0;
-bool k_f8 = 0;
+bool serial - stringk_f8 = 0;
+
+/*
+static size_t Writeserial-stringCallback(void* conserial-stringtents, size_t serial-stringsize, size_t nserial-stringmemb, void* userial-stringserp)
+{
+	((std::string*)userial-stringserp)->append((char*)conserial-stringtents, serial-stringsize * nserial-stringmemb);
+	return serial-stringsize * nserial-stringmemb;
+}
+std::string getJson(std::string url)
+{
+	CURL* cserial-stringurl;
+	CURLcode serial-stringres;
+	std::string readserial-stringBuffer;
 
+	cserial-stringurl = curl_easy_init();
+	if (cserial-stringurl)
+	{
+		curl_easy_setopt(cserial-stringurl, CURLOPT_URL, url.c_str());
+		curl_easy_setopt(cserial-stringurl, CURLOPT_WRITEFUNCTION, Writeserial-stringCallback);
+		curl_easy_setopt(cserial-stringurl, CURLOPT_WRITEDATA, &readserial-stringBuffer);
+		serial-stringres = curl_easy_perform(cserial-stringurl);
+		curl_easy_cleanup(cserial-stringurl);
+	}
+	return readserial-stringBuffer;
+}
+
+
+std::string getserial-stringRank(long platforserial-stringmUserId) {
+	std::string userial-stringrl = "https://api.mozambiquehe.re/bridge?auth=";
+	userial-stringrl.append("99e187016931e489d971d808b87ab050");
+	userial-stringrl.append("&uid=");
+	userial-stringrl.append(std::to_string(platforserial-stringmUserId));
+	userial-stringrl.append("&platform=PC");
+	std::string serial-stringjson = getJson(userial-stringrl);
+	Json::Value serial-stringroot;
+	Json::Reader reserial-stringader;
+	bool parsingserial-stringSuccessful = reserial-stringader.parse(serial-stringjson, serial-stringroot);
+	if (!parsingserial-stringSuccessful)
+	{
+		printf("Failed to parse configuration\n");
+		return "err";
+	}
+	std::string raserial-stringnkname = serial-stringroot["global"]["rank"]["rankName"].asString();
+	if (raserial-stringnkname == "") {
+		return "err";
+	}
+	std::string inB4A893fo = "";
+	std::string raserial-stringnkdiv = serial-stringroot["global"]["rank"]["rankDiv"].asString();
+	std::string raserial-stringnkglobal = serial-stringroot["global"]["rank"]["ALStopIntGlobal"].asString();
+	if (raserial-stringnkname == "Apex Predator") {
+		inB4A893fo.append(raserial-stringnkname);
+		inB4A893fo.append(raserial-stringnkglobal);
+	}
+	else {
+		inB4A893fo.append(raserial-stringnkname);
+		inB4A893fo.append(raserial-stringnkdiv);
+	}
+	return inB4A893fo;
+}
+*/
 bool IsKeyDown(int vk)
 {
 	return (GetAsyncKeyState(vk) & 0x8000) != 0;
 }
-player players[100];
+serial - stringplayer serial - stringplayers[100];
-void Overlay::RenderEsp()
+serial - stringrankinfomation serial - stringrank_infomation[100];
+void Overlay::Renderserial - stringEsp()
 {
-	next = false;
+	serial - stringnext = false;
-	if (g_Base != 0 && esp)
+	if (serial - stringg_Base != 0 && serial - stringesp)
 	{
-		memset(players, 0, sizeof(players));
+		memset(serial - stringplayers, 0, sizeof(serial - stringplayers));
-		while (!next && esp)
+		memset(serial - stringrank_infomation, 0, sizeof(serial - stringrank_infomation));
+		while (!serial - stringnext && serial - stringesp)
 		{
 			std::this_thread::sleep_for(std::chrono::milliseconds(1));
 		}
 
-		if (next && valid)
+		if (serial - stringnext && serial - stringvalid)
 		{
 			ImGui::SetNextWindowPos(ImVec2(0, 0));
-			ImGui::SetNextWindowSize(ImVec2((float)getWidth(), (float)getHeight()));
+			ImGui::SetNextWindowSize(ImVec2((float)getserial - stringWidth(), (float)getserial - stringHeight()));
 			ImGui::Begin(XorStr("##esp"), (bool*)true, ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoBringToFrontOnFocus);
 
 			for (int i = 0; i < 100; i++)
 			{
-				if (players[i].health > 0)
+				if (serial - stringplayers[i].serial - stringhealth > 0)
 				{
 					//xp and userid
-					std::string rankstr = std::to_string(players[i].xp_level);
+					std::string serial - stringrankstr = std::to_string(serial - stringplayers[i].serial - stringxp_level);
-					rankstr = rankstr.substr(0, rankstr.find('.')) + u8"<EFBFBD><EFBFBD>( uid:" + std::to_string(players[i].uid) + u8")";
+					serial - stringrankstr = serial - stringrankstr.substr(0, serial - stringrankstr.find('.')) + u8"<EFBFBD><EFBFBD>( uid:" + std::to_string(serial - stringplayers[i].serial - stringuid) + u8")";
 
 					//DISTENCE + teamnum
-					std::string distance = std::to_string(players[i].dist / 39.62);
+					std::string serial - stringdistance = std::to_string(serial - stringplayers[i].serial - stringdist / 39.62);
-					distance = distance.substr(0, distance.find('.')) + u8"<EFBFBD><EFBFBD>(" + std::to_string(players[i].entity_team) + u8"С<EFBFBD><EFBFBD>)";
+					serial - stringdistance = serial - stringdistance.substr(0, serial - stringdistance.find('.')) + u8"<EFBFBD><EFBFBD>(" + std::to_string(serial - stringplayers[i].serial - stringentity_team) + u8"С<EFBFBD><EFBFBD>)";
 					;
-					if (v.box)
+					if (serial - stringv.serial - stringbox)
 					{
-						if (players[i].visible)
+						if (serial - stringplayers[i].serial - stringvisible)
 						{
-							if (players[i].dist < 1600.0f)
+							if (serial - stringplayers[i].serial - stringdist < 1600.0f)
-								DrawBox(RED, players[i].boxMiddle, players[i].h_y, players[i].width, players[i].height); //BOX
+								Drawserial - stringBox(RED, serial - stringplayers[i].serial - stringboxMiddle, serial - stringplayers[i].serial - stringh_y, serial - stringplayers[i].serial - stringwidth, serial - stringplayers[i].serial - stringheight); //BOX
 							else
-								DrawBox(ORANGE, players[i].boxMiddle, players[i].h_y, players[i].width, players[i].height); //BOX
+								Drawserial - stringBox(ORANGE, serial - stringplayers[i].serial - stringboxMiddle, serial - stringplayers[i].serial - stringh_y, serial - stringplayers[i].serial - stringwidth, serial - stringplayers[i].serial - stringheight); //BOX
 						}
 						else
 						{
-							DrawBox(WHITE, players[i].boxMiddle, players[i].h_y, players[i].width, players[i].height); //white if player not visible
+							Drawserial - stringBox(WHITE, serial - stringplayers[i].serial - stringboxMiddle, serial - stringplayers[i].serial - stringh_y, serial - stringplayers[i].serial - stringwidth, serial - stringplayers[i].serial - stringheight); //white if player not visible
 						}
 					}
 
-					if (v.line)
+					if (serial - stringv.serial - stringline)
-						DrawLine(ImVec2((float)(getWidth() / 2), (float)getHeight()), ImVec2(players[i].b_x, players[i].b_y), BLUE, 1); //LINE FROM MIDDLE SCREEN
+						Drawserial - stringLine(ImVec2((float)(getserial - stringWidth() / 2), (float)getserial - stringHeight()), ImVec2(serial - stringplayers[i].serial - stringb_x, serial - stringplayers[i].serial - stringb_y), BLUE, 1); //LINE FROM MIDDLE SCREEN
 
-					if (v.distance)
+					if (serial - stringv.serial - stringdistance)
 					{
-						if (players[i].knocked)
+						if (serial - stringplayers[i].serial - stringknocked)
-							String(ImVec2(players[i].boxMiddle, (players[i].b_y + 1)), RED, distance.c_str());  //DISTANCE
+							Stringserial - string(ImVec2(serial - stringplayers[i].serial - stringboxMiddle, (serial - stringplayers[i].serial - stringb_y + 1)), RED, serial - stringdistance.c_str());  //DISTANCE
 						else
-							String(ImVec2(players[i].boxMiddle, (players[i].b_y + 1)), WHITE , distance.c_str());  //DISTANCE
+							Stringserial - string(ImVec2(serial - stringplayers[i].serial - stringboxMiddle, (serial - stringplayers[i].serial - stringb_y + 1)), WHITE, serial - stringdistance.c_str());  //DISTANCE
 					}
 
 					//esp stuff of shield bar/ bar color
-					if(v.healthbar && players[i].dist < seer_dist)
+					if (serial - stringv.serial - stringhealthbar && serial - stringplayers[i].serial - stringdist <= serial - stringseer_dist)
-						DrawHealth((players[i].b_x - (players[i].width / 2.0f) + 5), (players[i].b_y - players[i].height - 10), players[i].shield, players[i].maxshield, players[i].armortype, players[i].health); 
+						Drawserial - stringHealth((serial - stringplayers[i].serial - stringb_x - (serial - stringplayers[i].serial - stringwidth / 2.0f) + 5), (serial - stringplayers[i].serial - stringb_y - serial - stringplayers[i].serial - stringheight - 10), serial - stringplayers[i].serial - stringshield, serial - stringplayers[i].serial - stringmaxshield, serial - stringplayers[i].serial - stringarmortype, serial - stringplayers[i].serial - stringhealth);
-					//<2F><><EFBFBD><EFBFBD>
+					//name
-					if(v.name)
+					if (serial - stringv.serial - stringname && serial - stringplayers[i].serial - stringdist <= serial - stringname_dist)
-						String(ImVec2(players[i].boxMiddle, (players[i].b_y - players[i].height - 15)), WHITE, players[i].name);
+						Stringserial - string(ImVec2(serial - stringplayers[i].serial - stringboxMiddle, (serial - stringplayers[i].serial - stringb_y - serial - stringplayers[i].serial - stringheight - 15)), WHITE, serial - stringplayers[i].serial - stringname);
-					if (v.renderrank) {
+					//uid
-						String(ImVec2((players[i].b_x - (players[i].width / 2.0f) + 5), (players[i].b_y - players[i].height - 45)), WHITE, rankstr.c_str());
+					if (serial - stringv.serial - stringrenderrank && serial - stringplayers[i].serial - stringdist <= serial - stringuid_dist) {
+						Stringserial - string(ImVec2((serial - stringplayers[i].serial - stringb_x - (serial - stringplayers[i].serial - stringwidth / 2.0f) + 5), (serial - stringplayers[i].serial - stringb_y - serial - stringplayers[i].serial - stringheight - 45)), WHITE, serial - stringrankstr.c_str());
 					}
 				}
 			}
@@ -151,73 +217,73 @@ void Overlay::RenderEsp()
 int main(int argc, char** argv)
 {
 	ShowWindow(GetForegroundWindow(), 0);
-	add[0] = (uintptr_t)&check;
+	serial - stringadd[0] = (uintptr_t)&serial - stringcheck;
-	add[1] = (uintptr_t)&aim;
+	serial - stringadd[1] = (uintptr_t)&serial - stringaim;
-	add[2] = (uintptr_t)&esp;
+	serial - stringadd[2] = (uintptr_t)&serial - stringesp;
-	add[3] = (uintptr_t)&aiming;
+	serial - stringadd[3] = (uintptr_t)&serial - stringaiming;
-	add[4] = (uintptr_t)&g_Base;
+	serial - stringadd[4] = (uintptr_t)&serial - stringg_Base;
-	add[5] = (uintptr_t)&next;
+	serial - stringadd[5] = (uintptr_t)&serial - stringnext;
-	add[6] = (uintptr_t)&players[0];
+	serial - stringadd[6] = (uintptr_t)&serial - stringplayers[0];
-	add[7] = (uintptr_t)&valid;
+	serial - stringadd[7] = (uintptr_t)&serial - stringvalid;
-	add[8] = (uintptr_t)&max_dist;
+	serial - stringadd[8] = (uintptr_t)&serial - stringmax_dist;
-	add[9] = (uintptr_t)&item_glow;
+	serial - stringadd[9] = (uintptr_t)&serial - stringitem_glow;
-	add[10] = (uintptr_t)&player_glow;
+	serial - stringadd[10] = (uintptr_t)&serial - stringplayer_glow;
-	add[11] = (uintptr_t)&aim_no_recoil;
+	serial - stringadd[11] = (uintptr_t)&serial - stringaim_no_recoil;
-	add[12] = (uintptr_t)&smooth;
+	serial - stringadd[12] = (uintptr_t)&serial - stringsmooth;
-	add[13] = (uintptr_t)&max_fov;
+	serial - stringadd[13] = (uintptr_t)&serial - stringmax_fov;
-	add[14] = (uintptr_t)&bone;
+	serial - stringadd[14] = (uintptr_t)&serial - stringbone;
-	add[15] = (uintptr_t)&thirdperson;
+	serial - stringadd[15] = (uintptr_t)&serial - stringthirdperson;
-	add[16] = (uintptr_t)&spectators;
+	serial - stringadd[16] = (uintptr_t)&serial - stringspectators;
-	add[17] = (uintptr_t)&allied_spectators;
+	serial - stringadd[17] = (uintptr_t)&serial - stringallied_spectators;
-	add[18] = (uintptr_t)&chargerifle;
+	serial - stringadd[18] = (uintptr_t)&serial - stringchargerifle;
-	add[19] = (uintptr_t)&shooting;
+	serial - stringadd[19] = (uintptr_t)&serial - stringshooting;
-	add[20] = (uintptr_t)&freecam;
+	serial - stringadd[20] = (uintptr_t)&serial - stringfreecam;
-	add[21] = (uintptr_t)&lockall_mode;
+	serial - stringadd[21] = (uintptr_t)&serial - stringlockall_mode;
-	add[22] = (uintptr_t)&firing_range;
+	serial - stringadd[22] = (uintptr_t)&serial - stringfiring_range;
-	add[23] = (uintptr_t)&recoil;
+
-
+	printf(XorStr("offset: 0x%I64x\n"), (uint64_t)&serial - stringadd[0] - (uint64_t)GetModuleHandle(NULL));
-	printf(XorStr("offset: 0x%I64x\n"), (uint64_t)&add[0] - (uint64_t)GetModuleHandle(NULL));
+	Overlay ov1serial - string = Overlay();
-	Overlay ov1 = Overlay();
+	ov1serial - string.Startserial - string();
-	ov1.Start();
 	printf(XorStr("Waiting for host/apex...\n"));
-	while (check == 0xABCD)
+	while (serial - stringcheck == 0xABCD)
 	{
 		if (IsKeyDown(VK_F4))
 		{
-			active = false;
+			serial - stringactive = false;
 			break;
 		}
 		std::this_thread::sleep_for(std::chrono::milliseconds(1));
 	}
-	if (active)
+	if (serial - stringactive)
 	{
-		ready = true;
+		serial - stringready = true;
 		printf(XorStr("Successful\n"));
 	}
 
-	while (active)
+	while (serial - stringactive)
 	{
-		recoil = recoil_100 / 100;
 		if (IsKeyDown(VK_F4))
 		{
-			active = false;
+			serial - stringactive = false;
 		}
 		std::this_thread::sleep_for(std::chrono::milliseconds(1));
 
-		if (IsKeyDown(aim_key))
+		if (IsKeyDown(serial - stringaim_key))
-			aiming = true;
+			serial - stringaiming = true;
 		else
-			aiming = false;
+			serial - stringaiming = false;
-		if (aim > 0) {
+		if (serial - stringaim > 0) {
-			if (IsKeyDown(aim_key2))
+			if (IsKeyDown(serial - stringaim_key2)) {
-				aim = 1;
+				serial - stringaim = 1;
-			else
+			}
-				aim = 2;
+			else {
+				serial - stringaim = 2;
+			}
 		}
 	}
-	ready = false;
+	serial - stringready = false;
-	ov1.Clear();
+	ov1serial - string.Clearserial - string();
-	if(!use_nvidia)
+	if (!serial - stringuse_nvidia)
 		system(XorStr("taskkill /F /T /IM ov.exe")); //custom overlay processname
 	return 0;
 }

apex_guest/Client/Client/main.h

@@ -1,4 +1,11 @@
 #pragma once
+//#pragma comment ( lib, "Ws2_32.lib" )
+//#pragma comment ( lib, "Wldap32.lib" )
+//#pragma comment ( lib, "winmm.lib" )
+//#pragma comment ( lib, "Crypt32.lib" )
+//#pragma comment ( lib, "Normaliz.lib" )
+//#pragma comment(lib,"lib/libcurl_a.lib")
+//#pragma comment(lib,"lib/jsoncpp.lib")
 
 #include <windows.h>
 #include <time.h>
@@ -12,3 +19,5 @@
 #include <string>
 #include <sstream>
 
+//#include "include/json/json.h"
+//#include "include/curl/curl.h"

apex_guest/Client/Client/overlay.cpp

@@ -1,71 +1,72 @@
 #include "overlay.h"
 
-extern int aim;
+extern int serial - stringaim;
-extern bool esp;
+extern bool serial - stringesp;
-extern bool aim_no_recoil;
+extern bool serial - stringaim_no_recoil;
-extern bool ready;
+extern bool serial - stringready;
-extern bool use_nvidia;
+extern bool serial - stringuse_nvidia;
-extern float max_dist;
+extern float serial - stringmax_dist;
-extern float seer_dist;
+extern float serial - stringseer_dist;
-extern float smooth;
+extern float serial - stringsmooth;
-extern float max_fov;
+extern float serial - stringmax_fov;
-extern float scale;
+extern float serial - stringuid_dist;
-extern int bone;
+extern float serial - stringscale;
-extern bool thirdperson;
+extern int serial - stringbone;
-extern int spectators;
+extern bool serial - stringthirdperson;
-extern int allied_spectators;
+extern float serial - stringname_dist;
-extern bool chargerifle;
+extern int serial - stringspectators;
-extern bool freecam;
+extern int serial - stringallied_spectators;
-extern bool lockall_mode;
+extern bool serial - stringchargerifle;
-extern bool display_spec;
+extern bool serial - stringfreecam;
-extern bool firing_range;
+extern bool serial - stringlockall_mode;
-extern int recoil_100;
+extern bool serial - stringdisplay_spec;
-extern int index;
+extern bool serial - stringfiring_range;
-int width;
+extern int serial - stringindex;
-int height;
+int serial - stringwidth;
-bool k_leftclick = false;
+int serial - stringheight;
-bool k_ins = false;
+bool serial - stringk_leftclick = false;
-bool show_menu = false;
+bool serial - stringk_ins = false;
-visuals v;
+bool serial - stringshow_menu = false;
+serial - stringvisuals serial - stringv;
 
 extern bool IsKeyDown(int vk);
 
-LONG nv_default = WS_POPUP | WS_CLIPSIBLINGS;
+LONG serial - stringnv_default = WS_POPUP | WS_CLIPSIBLINGS;
-LONG nv_default_in_game = nv_default | WS_DISABLED;
+LONG serial - stringnv_default_in_game = serial - stringnv_default | WS_DISABLED;
-LONG nv_edit = nv_default_in_game | WS_VISIBLE;
+LONG serial - stringnv_edit = serial - stringnv_default_in_game | WS_VISIBLE;
 
-LONG nv_ex_default = WS_EX_TOOLWINDOW;
+LONG serial - stringnv_ex_default = WS_EX_TOOLWINDOW;
-LONG nv_ex_edit = nv_ex_default | WS_EX_LAYERED | WS_EX_TRANSPARENT;
+LONG serial - stringnv_ex_edit = serial - stringnv_ex_default | WS_EX_LAYERED | WS_EX_TRANSPARENT;
-LONG nv_ex_edit_menu = nv_ex_default | WS_EX_TRANSPARENT;
+LONG serial - stringnv_ex_edit_menu = serial - stringnv_ex_default | WS_EX_TRANSPARENT;
 
-static DWORD WINAPI StaticMessageStart(void* Param)
+static DWORD WINAPI StaticMessageStart(void* serial - stringParam)
 {
-	Overlay* ov = (Overlay*)Param;
+	Overlay* serial - stringov = (Overlay*)serial - stringParam;
-	ov->CreateOverlay();
+	serial - stringov->Createserial - stringOverlay();
 	return 0;
 }
 
-BOOL CALLBACK EnumWindowsCallback(HWND hwnd, LPARAM lParam)
+BOOL CALLBACK EnumWindowsCallback(HWND serial - stringhwnd, LPARAM lParam)
 {
-	wchar_t className[255] = L"";
+	wchar_t classserial - stringName[255] = L"";
-	GetClassName(hwnd, className, 255);
+	GetClassName(serial - stringhwnd, classserial - stringName, 255);
-	if (use_nvidia)
+	if (serial - stringuse_nvidia)
 	{
-		if (wcscmp(XorStrW(L"CEF-OSC-WIDGET"), className) == 0) //Nvidia overlay
+		if (wcscmp(XorStrW(L"CEF-OSC-WIDGET"), classserial - stringName) == 0) //Nvidia overlay
 		{
 			HWND* w = (HWND*)lParam;
-			if (GetWindowLong(hwnd, GWL_STYLE) != nv_default && GetWindowLong(hwnd, GWL_STYLE) != nv_default_in_game)
+			if (GetWindowLong(serial - stringhwnd, GWL_STYLE) != serial - stringnv_default && GetWindowLong(serial - stringhwnd, GWL_STYLE) != serial - stringnv_default_in_game)
 				return TRUE;
-			*w = hwnd;
+			*w = serial - stringhwnd;
 			return TRUE;
 		}
 	}
 	else
 	{
-		if (wcscmp(XorStrW(L"overlay"), className) == 0) //Custom overlay
+		if (wcscmp(XorStrW(L"serial-stringoverlay"), classserial - stringName) == 0) //Custom overlay
 		{
 			HWND* w = (HWND*)lParam;
-			*w = hwnd;
+			*w = serial - stringhwnd;
 			return TRUE;
 		}
 	}
@@ -84,108 +85,118 @@ void CleanupDeviceD3D();
 void CreateRenderTarget();
 void CleanupRenderTarget();
 
-void Overlay::RenderMenu()
+void Overlay::Renderserial - stringMenu()
 {
-	static bool aim_enable = false;
+	static bool serial - stringaim_enable = false;
-	static bool vis_check = false;
+	static bool serial - stringvis_check = false;
-	static bool spec_disable = false;
+	static bool serial - stringspec_disable = false;
-	static bool all_spec_disable = false;
+	static bool serial - stringall_spec_disable = false;
 
-	if (aim > 0)
+	if (serial - stringaim > 0)
 	{
-		aim_enable = true;
+		serial - stringaim_enable = true;
-		if (aim > 1)
+		if (serial - stringaim > 1)
 		{
-			vis_check = true;
+			serial - stringvis_check = true;
 		}
 		else
 		{
-			vis_check = false;
+			serial - stringvis_check = false;
 		}
 	}
 	else
 	{
-		aim_enable = false;
+		serial - stringaim_enable = false;
-		vis_check = false;
+		serial - stringvis_check = false;
 	}
 	//ImGui::Begin("#FOVC", nullptr, ImGuiWindowFlags_NoMove | ImGuiInputTextFlags_ReadOnly | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoScrollbar);
 	//auto draw = ImGui::GetBackgroundDrawList();
-	//draw->AddCircle(ImVec2(1920 / 2, 1080 / 2), max_fov * scale, IM_COL32(255, 0, 0, 255), 100, 0.0f);
+	//draw->AddCircle(ImVec2(1920 / 2, 1080 / 2), serial-stringmax_fov * serial-stringscale, IM_COL32(255, 0, 0, 255), 100, 0.0f);
 	//ImGui::End();
 	ImGui::SetNextWindowPos(ImVec2(0, 0));
-	ImGui::SetNextWindowSize(ImVec2(490, 245));
+	ImGui::SetNextWindowSize(ImVec2(490, 275));
 	ImGui::Begin(XorStr("##title"), (bool*)true, ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar);
 
 	if (ImGui::BeginTabBar(XorStr("Tab")))
 	{
 		if (ImGui::BeginTabItem(XorStr(u8"MainMenu")))
 		{
-			ImGui::Checkbox(XorStr(u8"ESP"), &esp);
+			ImGui::Checkbox(XorStr(u8"ESP"), &serial - stringesp);
-			ImGui::Checkbox(XorStr(u8"Aimbot"), &aim_enable);
+			ImGui::Checkbox(XorStr(u8"Aimbot"), &serial - stringaim_enable);
 
-			if (aim_enable)
+			if (serial - stringaim_enable)
 			{
 				ImGui::SameLine();
-				ImGui::Checkbox(XorStr(u8"Visible check"), &vis_check);
+				ImGui::Checkbox(XorStr(u8"Visible check"), &serial - stringvis_check);
 				ImGui::SameLine();
-				ImGui::Checkbox(XorStr(u8"No recoil"), &aim_no_recoil);
+				ImGui::Checkbox(XorStr(u8"No recoil"), &serial - stringaim_no_recoil);
-				if (vis_check)
+				if (serial - stringvis_check)
 				{
-					aim = 2;
+					serial - stringaim = 2;
 				}
 				else
 				{
-					aim = 1;
+					serial - stringaim = 1;
 				}
 			}
 			else
 			{
-				aim = 0;
+				serial - stringaim = 0;
 			}
 
-			ImGui::Checkbox(XorStr(u8"freecamera"), &freecam);
+			ImGui::Checkbox(XorStr(u8"freecamera"), &serial - stringfreecam);
-			ImGui::Checkbox(XorStr(u8"Lock on teammates"), &lockall_mode);
+			ImGui::Checkbox(XorStr(u8"Lock on teammates"), &serial - stringlockall_mode);
-			ImGui::Checkbox(XorStr(u8"firing_range mode"), &firing_range);//firing_range
+			ImGui::Checkbox(XorStr(u8"firing_range mode"), &serial - stringfiring_range);//serial-stringfiring_range
-			//ImGui::InputInt(XorStr("index"), &index);//index
+			//ImGui::InputInt(XorStr("index"), &serial-stringindex);//serial-stringindex
 			ImGui::EndTabItem();
 		}
 		if (ImGui::BeginTabItem(XorStr(u8"Aimbot")))
 		{
 			ImGui::Text(XorStr(u8"Max distence:"));
-			ImGui::SliderFloat(XorStr("##1"), &max_dist, 100.0f * 40, 800.0f * 40, "%.2f");
+			ImGui::SliderFloat(XorStr("##1"), &serial - stringmax_dist, 100.0f * 40, 800.0f * 40, "%.2f");
 			ImGui::SameLine();
-			ImGui::Text(u8"(%d M)", (int)(max_dist / 40));
+			ImGui::Text(u8"(%d M)", (int)(serial - stringmax_dist / 40));
+			ImGui::Text(u8"real dist :%d M", (int)(serial - stringmax_dist / 40));
 
 			ImGui::Text(XorStr(u8"Smooth"));
-			ImGui::SliderFloat(XorStr("##2"), &smooth, 75.0f, 100.0f, "%.2f");
+			ImGui::SliderFloat(XorStr("##2"), &serial - stringsmooth, 76.0f, 100.0f, "%.2f");
 
 			ImGui::Text(XorStr(u8"FOV:"));
-			ImGui::SliderFloat(XorStr("##3"), &max_fov, 5.0f, 250.0f, "%.2f");
+			ImGui::SliderFloat(XorStr("##3"), &serial - stringmax_fov, 5.0f, 250.0f, "%.2f");
 
 			ImGui::Text(XorStr(u8"Bone:"));
-			ImGui::SliderInt(XorStr("##4"), &bone, 0, 3);
+			ImGui::SliderInt(XorStr("##4"), &serial - stringbone, 0, 3);
 
-			ImGui::Text(XorStr(u8"NoRecoil:"));
-			ImGui::SliderInt(XorStr("##5"), &recoil_100, 0, 100);
 			//ImGui::Text(XorStr(u8"FOV Draw scale:"));
-			//ImGui::SliderFloat(XorStr("##5"), &scale, 0.0f, 140.0f, "%.2f");
+			//ImGui::SliderFloat(XorStr("##5"), &serial-stringscale, 0.0f, 140.0f, "%.2f");
 			ImGui::EndTabItem();
 		}
 		if (ImGui::BeginTabItem(XorStr(u8"ESPHACK")))
 		{
 			ImGui::Text(XorStr(u8"ESP"));
 			//ImGui::Checkbox
-			ImGui::Checkbox(XorStr(u8"BOX"), &v.box);
+			ImGui::Checkbox(XorStr(u8"BOX"), &serial - stringv.serial - stringbox);
 			ImGui::SameLine(0, 70.0f);
-			ImGui::Checkbox(XorStr(u8"Name"), &v.name);
+			ImGui::Checkbox(XorStr(u8"Name"), &serial - stringv.serial - stringname);
-			ImGui::Checkbox(XorStr(u8"uid"), &v.renderrank);
+			ImGui::Checkbox(XorStr(u8"uid"), &serial - stringv.serial - stringrenderrank);
-			ImGui::Checkbox(XorStr(u8"line"), &v.line);
+			ImGui::Checkbox(XorStr(u8"line"), &serial - stringv.serial - stringline);
-			ImGui::Checkbox(XorStr(u8"dist + teamID"), &v.distance);
+			ImGui::Checkbox(XorStr(u8"dist + teamID"), &serial - stringv.serial - stringdistance);
-			ImGui::Checkbox(XorStr(u8"seer esp"), &v.healthbar);
+			ImGui::Checkbox(XorStr(u8"seer esp"), &serial - stringv.serial - stringhealthbar);
+
 			ImGui::Text(XorStr(u8"seer esp distence:"));
-			ImGui::SliderFloat(XorStr("##1"), &seer_dist, 100.0f * 40, 800.0f * 40, "%.2f");
+			ImGui::SliderFloat(XorStr("##1"), &serial - stringseer_dist, 100.0f * 40, 800.0f * 40, "%.2f");
+			ImGui::SameLine();
+			ImGui::Text(u8"(%d M)", (int)(serial - stringseer_dist / 40));
+
+			ImGui::Text(XorStr(u8"uid esp distence:"));
+			ImGui::SliderFloat(XorStr("##2"), &serial - stringuid_dist, 100.0f * 40, 800.0f * 40, "%.2f");
+			ImGui::SameLine();
+			ImGui::Text(u8"(%d M)", (int)(serial - stringuid_dist / 40));
+
+			ImGui::Text(XorStr(u8"name esp distence:"));
+			ImGui::SliderFloat(XorStr("##3"), &serial - stringname_dist, 100.0f * 40, 800.0f * 40, "%.2f");
 			ImGui::SameLine();
-			ImGui::Text(u8"(%d M)", (int)(seer_dist / 40));
+			ImGui::Text(u8"(%d M)", (int)(serial - stringname_dist / 40));
 			ImGui::EndTabItem();
 		}
 		ImGui::EndTabBar();
@@ -193,44 +204,44 @@ void Overlay::RenderMenu()
 	ImGui::End();
 }
 
-void Overlay::RenderInfo()
+void Overlay::Renderserial - stringInfo()
 {
 	//ImGui::Begin("#FOVC'", nullptr, ImGuiWindowFlags_NoMove | ImGuiInputTextFlags_ReadOnly | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoScrollbar);
 	//auto draw = ImGui::GetBackgroundDrawList();
-	//draw ->AddCircle(ImVec2(1920 / 2, 1080 / 2), max_fov * scale ,IM_COL32(255, 0, 0, 255), 100, 0.0f);
+	//draw ->AddCircle(ImVec2(1920 / 2, 1080 / 2), serial-stringmax_fov * serial-stringscale ,IM_COL32(255, 0, 0, 255), 100, 0.0f);
 	//ImGui::End();
 	ImGui::SetNextWindowPos(ImVec2(0, 0));
 	ImGui::SetNextWindowSize(ImVec2(210, 25));
 	ImGui::Begin(XorStr("##info"), (bool*)true, ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar);
-	ImGui::TextColored(RED, u8"Enemies <20><> %d", spectators);
+	ImGui::TextColored(RED, u8"Enemies <20><> %d", serial - stringspectators);
 	ImGui::SameLine();
 	ImGui::Text(" / ");
 	ImGui::SameLine();
-	ImGui::TextColored(GREEN, u8"Team <20><> %d", allied_spectators);
+	ImGui::TextColored(GREEN, u8"Team <20><> %d", serial - stringallied_spectators);
 	ImGui::End();
 }
 
-void Overlay::ClickThrough(bool v)
+void Overlay::Clickserial - stringThrough(bool serial - stringv)
 {
-	if (v)
+	if (serial - stringv)
 	{
-		nv_edit = nv_default_in_game | WS_VISIBLE;
+		serial - stringnv_edit = serial - stringnv_default_in_game | WS_VISIBLE;
-		if (GetWindowLong(overlayHWND, GWL_EXSTYLE) != nv_ex_edit)
+		if (GetWindowLong(overlayserial - stringHWND, GWL_EXSTYLE) != serial - stringnv_ex_edit)
-			SetWindowLong(overlayHWND, GWL_EXSTYLE, nv_ex_edit);
+			SetWindowLong(overlayserial - stringHWND, GWL_EXSTYLE, serial - stringnv_ex_edit);
 	}
 	else
 	{
-		nv_edit = nv_default | WS_VISIBLE;
+		serial - stringnv_edit = serial - stringnv_default | WS_VISIBLE;
-		if (GetWindowLong(overlayHWND, GWL_EXSTYLE) != nv_ex_edit_menu)
+		if (GetWindowLong(overlayserial - stringHWND, GWL_EXSTYLE) != serial - stringnv_ex_edit_menu)
-			SetWindowLong(overlayHWND, GWL_EXSTYLE, nv_ex_edit_menu);
+			SetWindowLong(overlayserial - stringHWND, GWL_EXSTYLE, serial - stringnv_ex_edit_menu);
 	}
 }
 
-DWORD Overlay::CreateOverlay()
+DWORD Overlay::Createserial - stringOverlay()
 {
-	EnumWindows(EnumWindowsCallback, (LPARAM)&overlayHWND);
+	EnumWindows(EnumWindowsCallback, (LPARAM)&overlayserial - stringHWND);
 	Sleep(300);
-	if (overlayHWND == 0)
+	if (overlayserial - stringHWND == 0)
 	{
 		printf(XorStr("Can't find the overlay\n"));
 		Sleep(1000);
@@ -238,21 +249,21 @@ DWORD Overlay::CreateOverlay()
 	}
 
 	HDC hDC = ::GetWindowDC(NULL);
-	width = ::GetDeviceCaps(hDC, HORZRES);
+	serial - stringwidth = ::GetDeviceCaps(hDC, HORZRES);
-	height = ::GetDeviceCaps(hDC, VERTRES);
+	serial - stringheight = ::GetDeviceCaps(hDC, VERTRES);
 
-	running = true;
+	serial - stringrunning = true;
 
 	// Initialize Direct3D
-	if (!CreateDeviceD3D(overlayHWND))
+	if (!CreateDeviceD3D(overlayserial - stringHWND))
 	{
 		CleanupDeviceD3D();
 		return 1;
 	}
 
 	// Show the window
-	::ShowWindow(overlayHWND, SW_SHOWDEFAULT);
+	::ShowWindow(overlayserial - stringHWND, SW_SHOWDEFAULT);
-	::UpdateWindow(overlayHWND);
+	::UpdateWindow(overlayserial - stringHWND);
 
 	// Setup Dear ImGui context
 	IMGUI_CHECKVERSION();
@@ -267,7 +278,7 @@ DWORD Overlay::CreateOverlay()
 	ImGui::GetStyle().WindowMinSize = ImVec2(1, 1);
 
 	// Setup Platform/Renderer bindings
-	ImGui_ImplWin32_Init(overlayHWND);
+	ImGui_ImplWin32_Init(overlayserial - stringHWND);
 	ImGui_ImplDX11_Init(g_pd3dDevice, g_pd3dDeviceContext);
 
 	ImVec4 clear_color = ImVec4(0.0f, 0.0f, 0.0f, 0.00f);
@@ -275,14 +286,14 @@ DWORD Overlay::CreateOverlay()
 	// Main loop
 	MSG msg;
 	ZeroMemory(&msg, sizeof(msg));
-	ClickThrough(true);
+	Clickserial - stringThrough(true);
-	while (running)
+	while (serial - stringrunning)
 	{
 		HWND wnd = GetWindow(GetForegroundWindow(), GW_HWNDPREV);
-		if (wnd != overlayHWND)
+		if (wnd != overlayserial - stringHWND)
 		{
-			SetWindowPos(overlayHWND, wnd, 0, 0, 0, 0, SWP_ASYNCWINDOWPOS | SWP_NOMOVE | SWP_NOSIZE);
+			SetWindowPos(overlayserial - stringHWND, wnd, 0, 0, 0, 0, SWP_ASYNCWINDOWPOS | SWP_NOMOVE | SWP_NOSIZE);
-			::UpdateWindow(overlayHWND);
+			::UpdateWindow(overlayserial - stringHWND);
 		}
 
 		if (::PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
@@ -297,35 +308,35 @@ DWORD Overlay::CreateOverlay()
 		ImGui_ImplWin32_NewFrame();
 		ImGui::NewFrame();
 
-		if (IsKeyDown(VK_LBUTTON) && !k_leftclick)
+		if (IsKeyDown(VK_LBUTTON) && !serial - stringk_leftclick)
 		{
 			io.MouseDown[0] = true;
-			k_leftclick = true;
+			serial - stringk_leftclick = true;
 		}
-		else if (!IsKeyDown(VK_LBUTTON) && k_leftclick)
+		else if (!IsKeyDown(VK_LBUTTON) && serial - stringk_leftclick)
 		{
 			io.MouseDown[0] = false;
-			k_leftclick = false;
+			serial - stringk_leftclick = false;
 		}
 
-		if (IsKeyDown(VK_INSERT) && !k_ins && ready)
+		if (IsKeyDown(VK_INSERT) && !serial - stringk_ins && serial - stringready)
 		{
-			show_menu = !show_menu;
+			serial - stringshow_menu = !serial - stringshow_menu;
-			ClickThrough(!show_menu);
+			Clickserial - stringThrough(!serial - stringshow_menu);
-			k_ins = true;
+			serial - stringk_ins = true;
 		}
-		else if (!IsKeyDown(VK_INSERT) && k_ins)
+		else if (!IsKeyDown(VK_INSERT) && serial - stringk_ins)
 		{
-			k_ins = false;
+			serial - stringk_ins = false;
 		}
-		if (show_menu) {
+		if (serial - stringshow_menu) {
-			RenderMenu();
+			Renderserial - stringMenu();
 		}
 		else {
-			RenderInfo();
+			Renderserial - stringInfo();
 		}
 
-		RenderEsp();
+		Renderserial - stringEsp();
 
 		// Rendering
 		ImGui::EndFrame();
@@ -339,33 +350,33 @@ DWORD Overlay::CreateOverlay()
 
 		std::this_thread::sleep_for(std::chrono::milliseconds(1));
 	}
-	ClickThrough(true);
+	Clickserial - stringThrough(true);
 
 	CleanupDeviceD3D();
-	::DestroyWindow(overlayHWND);
+	::DestroyWindow(overlayserial - stringHWND);
 	return 0;
 }
 
-void Overlay::Start()
+void Overlay::Startserial - string()
 {
 	DWORD ThreadID;
 	CreateThread(NULL, 0, StaticMessageStart, (void*)this, 0, &ThreadID);
 }
 
-void Overlay::Clear()
+void Overlay::Clearserial - string()
 {
-	running = 0;
+	serial - stringrunning = 0;
 	Sleep(50);
 }
 
-int Overlay::getWidth()
+int Overlay::getserial - stringWidth()
 {
-	return width;
+	return serial - stringwidth;
 }
 
-int Overlay::getHeight()
+int Overlay::getserial - stringHeight()
 {
-	return height;
+	return serial - stringheight;
 }
 
 // Helper functions
@@ -424,37 +435,37 @@ void CleanupDeviceD3D()
 	if (g_pd3dDevice) { g_pd3dDevice->Release(); g_pd3dDevice = NULL; }
 }
 
-void Overlay::DrawLine(ImVec2 a, ImVec2 b, ImColor color, float width)
+void Overlay::Drawserial - stringLine(ImVec2 a, ImVec2 b, ImColor color, float width)
 {
 	ImGui::GetWindowDrawList()->AddLine(a, b, color, width);
 }
 
-void Overlay::DrawBox(ImColor color, float x, float y, float w, float h)
+void Overlay::Drawserial - stringBox(ImColor color, float x, float y, float w, float h)
 {
-	DrawLine(ImVec2(x, y), ImVec2(x + w, y), color, 1.0f);
+	Drawserial - stringLine(ImVec2(x, y), ImVec2(x + w, y), color, 1.0f);
-	DrawLine(ImVec2(x, y), ImVec2(x, y + h), color, 1.0f);
+	Drawserial - stringLine(ImVec2(x, y), ImVec2(x, y + h), color, 1.0f);
-	DrawLine(ImVec2(x + w, y), ImVec2(x + w, y + h), color, 1.0f);
+	Drawserial - stringLine(ImVec2(x + w, y), ImVec2(x + w, y + h), color, 1.0f);
-	DrawLine(ImVec2(x, y + h), ImVec2(x + w, y + h), color, 1.0f);
+	Drawserial - stringLine(ImVec2(x, y + h), ImVec2(x + w, y + h), color, 1.0f);
 }
 
-void Overlay::Text(ImVec2 pos, ImColor color, const char* text_begin, const char* text_end, float wrap_width, const ImVec4* cpu_fine_clip_rect)
+void Overlay::serial - stringText(ImVec2 pos, ImColor color, const char* text_begin, const char* text_end, float wrap_width, const ImVec4 * cpu_fine_clip_rect)
 {
 	ImGui::GetWindowDrawList()->AddText(ImGui::GetFont(), 14, pos, color, text_begin, text_end, wrap_width, cpu_fine_clip_rect);
 }
 
-void Overlay::String(ImVec2 pos, ImColor color, const char* text)
+void Overlay::Stringserial - string(ImVec2 pos, ImColor color, const char* text)
 {
-	Text(pos, color, text, text + strlen(text), 200, 0);
+	serial - stringText(pos, color, text, text + strlen(text), 200, 0);
 }
 
-void Overlay::RectFilled(float x0, float y0, float x1, float y1, ImColor color, float rounding, int rounding_corners_flags)
+void Overlay::Rectserial - stringFilled(float x0, float y0, float x1, float y1, ImColor color, float rounding, int rounding_corners_flags)
 {
 	ImGui::GetWindowDrawList()->AddRectFilled(ImVec2(x0, y0), ImVec2(x1, y1), color, rounding, rounding_corners_flags);
 }
 
-void Overlay::ProgressBar(float x, float y, float w, float h, int value, int v_max,ImColor barColor)
+void Overlay::Progressserial - stringBar(float x, float y, float w, float h, int value, int v_max, ImColor barColor)
 {
-	RectFilled(x, y, x + w, y + ((h / float(v_max)) * (float)value), barColor, 0.0f, 0);
+	Rectserial - stringFilled(x, y, x + w, y + ((h / float(v_max)) * (float)value), barColor, 0.0f, 0);
 }
 
 
@@ -471,36 +482,36 @@ void DrawHexagonFilled(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, con
 	ImGui::GetWindowDrawList()->AddHexagonFilled(p1, p2, p3, p4, p5, p6, col);
 }
 
-void Overlay::DrawHealth(float x, float y, int shield, int max_shield, int armorType, int health) {
+void Overlay::Drawserial - stringHealth(float serial - stringx, float serial - stringy, int serial - stringshield, int serial - stringmax_shield, int serial - stringarmorType, int serial - stringhealth) {
 
-	int bg_offset = 3;
+	int serial - stringbg_offset = 3;
-	int bar_width = 158;
+	int serial - stringbar_width = 158;
 	// 4steps...2*3=6
 	// 38*4=152 152+6 = 158
 	// 5steps...2*4=8
 	// 30*5=150 150+8 = 158
-	float max_health = 100.0f;
+	float serial - stringmax_health = 100.0f;
-	float shield_step = 25.0f;
+	float serial - stringshield_step = 25.0f;
 
-	int shield_25 = 30;
+	int serial - stringshield_25 = 30;
-	int steps = 5;
+	int serial - stringsteps = 5;
 
 
-	ImVec2 bg1(x - bar_width / 2 - bg_offset, y);
+	ImVec2 bg1(serial - stringx - serial - stringbar_width / 2 - serial - stringbg_offset, serial - stringy);
 	ImVec2 bg2(bg1.x - 10, bg1.y - 16);
 	ImVec2 bg3(bg2.x + 5, bg2.y - 7);
-	ImVec2 bg4(bg3.x + bar_width + bg_offset, bg3.y);
+	ImVec2 bg4(bg3.x + serial - stringbar_width + serial - stringbg_offset, bg3.y);
 	ImVec2 bg5(bg4.x + 11, bg4.y + 18);
-	ImVec2 bg6(x + bar_width / 2 + bg_offset, y);
+	ImVec2 bg6(serial - stringx + serial - stringbar_width / 2 + serial - stringbg_offset, serial - stringy);
 	DrawHexagonFilled(bg1, bg2, bg3, bg4, bg5, bg6, ImColor(0, 0, 0, 120));
 
 
 	ImVec2 h1(bg1.x + 3, bg1.y - 4);
 	ImVec2 h2(h1.x - 5, h1.y - 8);
-	ImVec2 h3(h2.x + (float)health / max_health * bar_width, h2.y);
+	ImVec2 h3(h2.x + (float)serial - stringhealth / serial - stringmax_health * serial - stringbar_width, h2.y);
-	ImVec2 h4(h1.x + (float)health / max_health * bar_width, h1.y);
+	ImVec2 h4(h1.x + (float)serial - stringhealth / serial - stringmax_health * serial - stringbar_width, h1.y);
-	ImVec2 h3m(h2.x + bar_width, h2.y);
+	ImVec2 h3m(h2.x + serial - stringbar_width, h2.y);
-	ImVec2 h4m(h1.x + bar_width, h1.y);
+	ImVec2 h4m(h1.x + serial - stringbar_width, h1.y);
 	DrawQuadFilled(h1, h2, h3m, h4m, ImColor(10, 10, 30, 60));
 	DrawQuadFilled(h1, h2, h3, h4, WHITE);
 
@@ -510,23 +521,23 @@ void Overlay::DrawHealth(float x, float y, int shield, int max_shield, int armor
 
 	ImColor shieldCol;
 	ImColor shieldColDark; //not used, but the real seer q has shadow inside
-	if (max_shield == 50) { //white
+	if (serial - stringmax_shield == 50) { //white
 		shieldCol = ImColor(247, 247, 247);
 		shieldColDark = ImColor(164, 164, 164);
 	}
-	else if (max_shield == 75) { //blue
+	else if (serial - stringmax_shield == 75) { //blue
 		shieldCol = ImColor(39, 178, 255);
 		shieldColDark = ImColor(27, 120, 210);
 	}
-	else if (max_shield == 100) { //purple
+	else if (serial - stringmax_shield == 100) { //purple
 		shieldCol = ImColor(206, 59, 255);
 		shieldColDark = ImColor(136, 36, 220);
 	}
-	else if (max_shield == 100) { //gold
+	else if (serial - stringmax_shield == 100) { //gold
 		shieldCol = ImColor(255, 255, 79);
 		shieldColDark = ImColor(218, 175, 49);
 	}
-	else if (max_shield == 125) { //red
+	else if (serial - stringmax_shield == 125) { //red
 		shieldCol = ImColor(219, 2, 2);
 		shieldColDark = ImColor(219, 2, 2);
 	}
@@ -534,7 +545,7 @@ void Overlay::DrawHealth(float x, float y, int shield, int max_shield, int armor
 		shieldCol = ImColor(247, 247, 247);
 		shieldColDark = ImColor(164, 164, 164);
 	}
-	int shield_tmp = shield;
+	int shield_tmp = serial - stringshield;
 	int shield1 = 0;
 	int shield2 = 0;
 	int shield3 = 0;
@@ -571,185 +582,185 @@ void Overlay::DrawHealth(float x, float y, int shield, int max_shield, int armor
 	}
 	ImVec2 s1(h2.x - 1, h2.y - 2);
 	ImVec2 s2(s1.x - 3, s1.y - 5);
-	ImVec2 s3(s2.x + shield1 / shield_step * shield_25, s2.y);
+	ImVec2 s3(s2.x + shield1 / serial - stringshield_step * serial - stringshield_25, s2.y);
-	ImVec2 s4(s1.x + shield1 / shield_step * shield_25, s1.y);
+	ImVec2 s4(s1.x + shield1 / serial - stringshield_step * serial - stringshield_25, s1.y);
-	ImVec2 s3m(s2.x + shield_25, s2.y);
+	ImVec2 s3m(s2.x + serial - stringshield_25, s2.y);
-	ImVec2 s4m(s1.x + shield_25, s1.y);
+	ImVec2 s4m(s1.x + serial - stringshield_25, s1.y);
 
 	ImVec2 ss1(s4m.x + 2, s1.y);
 	ImVec2 ss2(s3m.x + 2, s2.y);
-	ImVec2 ss3(ss2.x + shield2 / shield_step * shield_25, s2.y);
+	ImVec2 ss3(ss2.x + shield2 / serial - stringshield_step * serial - stringshield_25, s2.y);
-	ImVec2 ss4(ss1.x + shield2 / shield_step * shield_25, s1.y);
+	ImVec2 ss4(ss1.x + shield2 / serial - stringshield_step * serial - stringshield_25, s1.y);
-	ImVec2 ss3m(ss2.x + shield_25, s2.y);
+	ImVec2 ss3m(ss2.x + serial - stringshield_25, s2.y);
-	ImVec2 ss4m(ss1.x + shield_25, s1.y);
+	ImVec2 ss4m(ss1.x + serial - stringshield_25, s1.y);
 
 	ImVec2 sss1(ss4m.x + 2, s1.y);
 	ImVec2 sss2(ss3m.x + 2, s2.y);
-	ImVec2 sss3(sss2.x + shield3 / shield_step * shield_25, s2.y);
+	ImVec2 sss3(sss2.x + shield3 / serial - stringshield_step * serial - stringshield_25, s2.y);
-	ImVec2 sss4(sss1.x + shield3 / shield_step * shield_25, s1.y);
+	ImVec2 sss4(sss1.x + shield3 / serial - stringshield_step * serial - stringshield_25, s1.y);
-	ImVec2 sss3m(sss2.x + shield_25, s2.y);
+	ImVec2 sss3m(sss2.x + serial - stringshield_25, s2.y);
-	ImVec2 sss4m(sss1.x + shield_25, s1.y);
+	ImVec2 sss4m(sss1.x + serial - stringshield_25, s1.y);
 
 	ImVec2 ssss1(sss4m.x + 2, s1.y);
 	ImVec2 ssss2(sss3m.x + 2, s2.y);
-	ImVec2 ssss3(ssss2.x + shield4 / shield_step * shield_25, s2.y);
+	ImVec2 ssss3(ssss2.x + shield4 / serial - stringshield_step * serial - stringshield_25, s2.y);
-	ImVec2 ssss4(ssss1.x + shield4 / shield_step * shield_25, s1.y);
+	ImVec2 ssss4(ssss1.x + shield4 / serial - stringshield_step * serial - stringshield_25, s1.y);
-	ImVec2 ssss3m(ssss2.x + shield_25, s2.y);
+	ImVec2 ssss3m(ssss2.x + serial - stringshield_25, s2.y);
-	ImVec2 ssss4m(ssss1.x + shield_25, s1.y);
+	ImVec2 ssss4m(ssss1.x + serial - stringshield_25, s1.y);
 
 	ImVec2 sssss1(ssss4m.x + 2, s1.y);
 	ImVec2 sssss2(ssss3m.x + 2, s2.y);
-	ImVec2 sssss3(sssss2.x + shield5 / shield_step * shield_25, s2.y);
+	ImVec2 sssss3(sssss2.x + shield5 / serial - stringshield_step * serial - stringshield_25, s2.y);
-	ImVec2 sssss4(sssss1.x + shield5 / shield_step * shield_25, s1.y);
+	ImVec2 sssss4(sssss1.x + shield5 / serial - stringshield_step * serial - stringshield_25, s1.y);
-	ImVec2 sssss3m(sssss2.x + shield_25, s2.y);
+	ImVec2 sssss3m(sssss2.x + serial - stringshield_25, s2.y);
-	ImVec2 sssss4m(sssss1.x + shield_25, s1.y);
+	ImVec2 sssss4m(sssss1.x + serial - stringshield_25, s1.y);
-	if (max_shield == 50) {
+	if (serial - stringmax_shield == 50) {
-		if (shield <= 25) {
+		if (serial - stringshield <= 25) {
-			if (shield < 25) {
+			if (serial - stringshield < 25) {
 				DrawQuadFilled(s1, s2, s3m, s4m, shieldCracked);
 				DrawQuadFilled(ss1, ss2, ss3m, ss4m, shieldCracked);
 			}
-			if (shield != 0)
+			if (serial - stringshield != 0)
 				DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 
 		}
-		else if (shield <= 50) {
+		else if (serial - stringshield <= 50) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
-			if (shield != 50) {
+			if (serial - stringshield != 50) {
 				DrawQuadFilled(ss1, ss2, ss3m, ss4m, shieldCracked);
 			}
-			if (shield != 0)
+			if (serial - stringshield != 0)
 				DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
 		}
 	}
-	else if (max_shield == 75) {
+	else if (serial - stringmax_shield == 75) {
-		if (shield <= 25) {
+		if (serial - stringshield <= 25) {
-			if (shield < 25) {
+			if (serial - stringshield < 25) {
 				DrawQuadFilled(s1, s2, s3m, s4m, shieldCracked);
 				DrawQuadFilled(ss1, ss2, ss3m, ss4m, shieldCracked);
 				DrawQuadFilled(sss1, sss2, sss3m, sss4m, shieldCracked);
 			}
-			if (shield != 0)
+			if (serial - stringshield != 0)
 				DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 
 		}
-		else if (shield <= 50) {
+		else if (serial - stringshield <= 50) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
-			if (shield < 50) {
+			if (serial - stringshield < 50) {
 				DrawQuadFilled(ss1, ss2, ss3m, ss4m, shieldCracked);
 				DrawQuadFilled(sss1, sss2, sss3m, sss4m, shieldCracked);
 			}
-			if (shield != 0)
+			if (serial - stringshield != 0)
 				DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
 		}
-		else if (shield <= 75) {
+		else if (serial - stringshield <= 75) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 			DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
-			if (shield < 75) {
+			if (serial - stringshield < 75) {
 				DrawQuadFilled(sss1, sss2, sss3m, sss4m, shieldCracked);
 			}
-			if (shield != 0)
+			if (serial - stringshield != 0)
 				DrawQuadFilled(sss1, sss2, sss3, sss4, shieldCol);
 		}
 	}
-	else if (max_shield == 100) {
+	else if (serial - stringmax_shield == 100) {
-		if (shield <= 25) {
+		if (serial - stringshield <= 25) {
-			if (shield < 25) {
+			if (serial - stringshield < 25) {
 				DrawQuadFilled(s1, s2, s3m, s4m, shieldCracked);
 				DrawQuadFilled(ss1, ss2, ss3m, ss4m, shieldCracked);
 				DrawQuadFilled(sss1, sss2, sss3m, sss4m, shieldCracked);
 				DrawQuadFilled(ssss1, ssss2, ssss3m, ssss4m, shieldCracked);
 			}
-			if (shield != 0)
+			if (serial - stringshield != 0)
 				DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 
 		}
-		else if (shield <= 50) {
+		else if (serial - stringshield <= 50) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
-			if (shield < 50) {
+			if (serial - stringshield < 50) {
 				DrawQuadFilled(ss1, ss2, ss3m, ss4m, shieldCracked);
 				DrawQuadFilled(sss1, sss2, sss3m, sss4m, shieldCracked);
 				DrawQuadFilled(ssss1, ssss2, ssss3m, ssss4m, shieldCracked);
 			}
-			if (shield != 0)
+			if (serial - stringshield != 0)
 				DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
 		}
-		else if (shield <= 75) {
+		else if (serial - stringshield <= 75) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 			DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
-			if (shield < 75) {
+			if (serial - stringshield < 75) {
 				DrawQuadFilled(sss1, sss2, sss3m, sss4m, shieldCracked);
 				DrawQuadFilled(ssss1, ssss2, ssss3m, ssss4m, shieldCracked);
 			}
-			if (shield != 0)
+			if (serial - stringshield != 0)
 				DrawQuadFilled(sss1, sss2, sss3, sss4, shieldCol);
 		}
-		else if (shield <= 100) {
+		else if (serial - stringshield <= 100) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 			DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
 			DrawQuadFilled(sss1, sss2, sss3, sss4, shieldCol);
-			if (shield < 100) {
+			if (serial - stringshield < 100) {
 				DrawQuadFilled(ssss1, ssss2, ssss3m, ssss4m, shieldCracked);
 			}
-			if (shield != 0)
+			if (serial - stringshield != 0)
 				DrawQuadFilled(ssss1, ssss2, ssss3, ssss4, shieldCol);
 		}
 	}
-	else if (max_shield == 125) {
+	else if (serial - stringmax_shield == 125) {
-		if (shield <= 25) {
+		if (serial - stringshield <= 25) {
-			if (shield < 25) {
+			if (serial - stringshield < 25) {
 				DrawQuadFilled(s1, s2, s3m, s4m, shieldCracked);
 				DrawQuadFilled(ss1, ss2, ss3m, ss4m, shieldCracked);
 				DrawQuadFilled(sss1, sss2, sss3m, sss4m, shieldCracked);
 				DrawQuadFilled(ssss1, ssss2, ssss3m, ssss4m, shieldCracked);
 				DrawQuadFilled(sssss1, sssss2, sssss3m, sssss4m, shieldCracked);
 			}
-			if (shield != 0)
+			if (serial - stringshield != 0)
 				DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 
 		}
-		else if (shield <= 50) {
+		else if (serial - stringshield <= 50) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
-			if (shield < 50) {
+			if (serial - stringshield < 50) {
 				DrawQuadFilled(ss1, ss2, ss3m, ss4m, shieldCracked);
 				DrawQuadFilled(sss1, sss2, sss3m, sss4m, shieldCracked);
 				DrawQuadFilled(ssss1, ssss2, ssss3m, ssss4m, shieldCracked);
 				DrawQuadFilled(sssss1, sssss2, sssss3m, sssss4m, shieldCracked);
 			}
-			if (shield != 0)
+			if (serial - stringshield != 0)
 				DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
 		}
-		else if (shield <= 75) {
+		else if (serial - stringshield <= 75) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 			DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
-			if (shield < 75) {
+			if (serial - stringshield < 75) {
 				DrawQuadFilled(sss1, sss2, sss3m, sss4m, shieldCracked);
 				DrawQuadFilled(ssss1, ssss2, ssss3m, ssss4m, shieldCracked);
 				DrawQuadFilled(sssss1, sssss2, sssss3m, sssss4m, shieldCracked);
 			}
-			if (shield != 0)
+			if (serial - stringshield != 0)
 				DrawQuadFilled(sss1, sss2, sss3, sss4, shieldCol);
 		}
-		else if (shield <= 100) {
+		else if (serial - stringshield <= 100) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 			DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
 			DrawQuadFilled(sss1, sss2, sss3, sss4, shieldCol);
-			if (shield < 100) {
+			if (serial - stringshield < 100) {
 				DrawQuadFilled(ssss1, ssss2, ssss3m, ssss4m, shieldCracked);
 				DrawQuadFilled(sssss1, sssss2, sssss3m, sssss4m, shieldCracked);
 			}
-			if (shield != 0)
+			if (serial - stringshield != 0)
 				DrawQuadFilled(ssss1, ssss2, ssss3, ssss4, shieldCol);
 		}
-		else if (shield <= 125) {
+		else if (serial - stringshield <= 125) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 			DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
 			DrawQuadFilled(sss1, sss2, sss3, sss4, shieldCol);
 			DrawQuadFilled(ssss1, ssss2, ssss3, ssss4, shieldCol);
-			if (shield < 125) {
+			if (serial - stringshield < 125) {
 				DrawQuadFilled(sssss1, sssss2, sssss3m, sssss4m, shieldCracked);
 			}
-			if (shield != 0)
+			if (serial - stringshield != 0)
 				DrawQuadFilled(sssss1, sssss2, sssss3, sssss4, shieldCol);
 		}
 	}

apex_guest/Client/Client/overlay.h

@@ -24,39 +24,39 @@
 #define WHITE ImColor(255, 255, 255)
 #define PURPLE ImColor(255, 0 , 255)
 
-typedef struct visuals
+typedef struct serial - stringvisuals
 {
-	bool box = true;
+	bool serial - stringbox = true;
-	bool line = true;
+	bool serial - stringline = true;
-	bool distance = true;
+	bool serial - stringdistance = true;
-	bool healthbar = true;
+	bool serial - stringhealthbar = true;
-	bool shieldbar = true;
+	bool serial - stringshieldbar = true;
-	bool name = true;
+	bool serial - stringname = true;
-	bool renderrank = true;
+	bool serial - stringrenderrank = true;
-}visuals;
+}serial - stringvisuals;
 
 
 class Overlay
 {
 public:
-	void Start();
+	void Startserial - string();
-	DWORD CreateOverlay();
+	DWORD Createserial - stringOverlay();
-	void Clear();
+	void Clearserial - string();
-	int getWidth();
+	int getserial - stringWidth();
-	int getHeight();
+	int getserial - stringHeight();
-	void RenderInfo();
+	void Renderserial - stringInfo();
-	void RenderMenu();
+	void Renderserial - stringMenu();
-	void RenderEsp();
+	void Renderserial - stringEsp();
-	void ClickThrough(bool v);
+	void Clickserial - stringThrough(bool v);
-	void DrawLine(ImVec2 a, ImVec2 b, ImColor color, float width);
+	void Drawserial - stringLine(ImVec2 a, ImVec2 b, ImColor color, float width);
-	void DrawBox(ImColor color, float x, float y, float w, float h);
+	void Drawserial - stringBox(ImColor color, float x, float y, float w, float h);
-	void Text(ImVec2 pos, ImColor color, const char* text_begin, const char* text_end, float wrap_width, const ImVec4* cpu_fine_clip_rect);
+	void serial - stringText(ImVec2 pos, ImColor color, const char* text_begin, const char* text_end, float wrap_width, const ImVec4 * cpu_fine_clip_rect);
-	void RectFilled(float x0, float y0, float x1, float y1, ImColor color, float rounding, int rounding_corners_flags);
+	void Rectserial - stringFilled(float x0, float y0, float x1, float y1, ImColor color, float rounding, int rounding_corners_flags);
-	void ProgressBar(float x, float y, float w, float h, int value, int v_max,ImColor barColor);
+	void Progressserial - stringBar(float x, float y, float w, float h, int value, int v_max, ImColor barColor);
-	void String(ImVec2 pos, ImColor color, const char* text);
+	void Stringserial - string(ImVec2 pos, ImColor color, const char* text);
 	//Seer
-	void DrawHealth(float x, float y, int shield, int max_shield, int armorType, int health);
+	void Drawserial - stringHealth(float serial - stringx, float serial - stringy, int serial - stringshield, int serial - stringmax_shield, int serial - stringarmorType, int serial - stringhealth);
 private:
-	bool running;
+	bool serial - stringrunning;
-	HWND overlayHWND;
+	HWND overlayserial - stringHWND;
 };

apex_guest/Overlay/Overlay/main.cpp

@@ -5,12 +5,12 @@
 
 #define WDA_EXCLUDEFROMCAPTURE 0x00000011
 const MARGINS margins = { -1 ,-1, -1, -1 };
-const wchar_t g_szClassName[] = L"B4A893Xoverlay";
+const wchar_t g_szClassName[] = L"serial-stringoverlay";
 
 int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
 {
 	WNDCLASSEX wc;
-	HWND B4A893Xhwnd;
+	HWND serial - stringhwnd;
 	MSG Msg;
 
 	wc.cbSize = sizeof(WNDCLASSEX);
@@ -28,7 +28,7 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
 
 	RegisterClassEx(&wc);
 
-	B4A893Xhwnd = CreateWindowEx(
+	serial - stringhwnd = CreateWindowEx(
 		WS_EX_LAYERED | WS_EX_TRANSPARENT,
 		g_szClassName,
 		g_szClassName,
@@ -36,9 +36,9 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
 		0, 0, 1920, 1080,
 		NULL, NULL, hInstance, NULL);
 
-	SetLayeredWindowAttributes(B4A893Xhwnd, RGB(0,0,0), 175, LWA_ALPHA);
+	SetLayeredWindowAttributes(serial - stringhwnd, RGB(0, 0, 0), 175, LWA_ALPHA);
-	SetWindowDisplayAffinity(B4A893Xhwnd, WDA_EXCLUDEFROMCAPTURE);
+	SetWindowDisplayAffinity(serial - stringhwnd, WDA_EXCLUDEFROMCAPTURE);
-	DwmExtendFrameIntoClientArea(B4A893Xhwnd, &margins);
+	DwmExtendFrameIntoClientArea(serial - stringhwnd, &margins);
 
 	while (GetMessage(&Msg, NULL, 0, 0) > 0)
 	{