From b6f778f2142e51a9b080eebb6e10b60f408560bf Mon Sep 17 00:00:00 2001
From: Abdul Moez <72302783+Anonym0usWork1221@users.noreply.github.com>
Date: Fri, 22 Sep 2023 15:02:32 +0500
Subject: [PATCH] Threading errors and non decleared variables patch

There was error on Freeze threading part and one function was out of boundery which was causing the program to crash. Created working main.cpp file
---
 MemoryTool.cpp | 6651 ++++++++++++++++++++++++------------------------
 MemoryTool.h   |  463 ++--
 main.cpp       |   44 +-
 3 files changed, 3610 insertions(+), 3548 deletions(-)

diff --git a/MemoryTool.cpp b/MemoryTool.cpp
index 020c8e7..7015e8c 100644
--- a/MemoryTool.cpp
+++ b/MemoryTool.cpp
@@ -1,3294 +1,3357 @@
-#include "MemoryTool.h"
-#include <stdio.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <fcntl.h>
-#include <dirent.h>
-#include <thread>
-#include <cstring>
-#include <cstddef>
-#include <cstdint>
-#include <pthread.h>
-
-using namespace std;
-
-void MemoryTool::initXMemoryTools(char *b, char *mode) {
-	strcpy(bm, b);
-	if (strcmp(mode, MODE_ROOT)==0) {
-		if (getuid() != 0) {
-			system("echo starting");
-			exit(1);
-		}
-	}
-	system("echo 0 > /proc/sys/fs/inotify/max_user_watches");
-	//system("echo 0 > /proc/sys/fs/inotify/max_queued_events");
-	pid_t pid = getPID(b);
-	if (pid == 0) {
-		printf("\033[31;1m");
-		puts("Failed to get process!");
-		exit(1);
-	}
-	char lj[64];
-	sprintf(lj, "/proc/%d/mem", pid);
-	process_handle = open(lj, O_RDWR);
-	if (process_handle == -1) {
-		printf("\033[31;1m");
-		puts("Failed to get mem!");
-		exit(1);
-	}
-	lseek(process_handle, 0, SEEK_SET);
-}
-
-int MemoryTool::GetResultCount() {
-	return gs;
-}
-
-bool MemoryTool::snowpd(long int a2) {
-	return a2 <= 7999 && a2 > 31;
-}
-
-DWORD MemoryTool::GetAddressValue_DWORD(ADDRESS addr) {
-	DWORD buf;
-	pread64(process_handle, &buf, sizeof(DWORD), addr);
-	return buf;
-}
-
-FLOAT MemoryTool::GetAddressValue_FLOAT(ADDRESS addr) {
-	FLOAT buf;
-	pread64(process_handle, &buf, sizeof(FLOAT), addr);
-	return buf;
-}
-
-DOUBLE MemoryTool::GetAddressValue_DOUBLE(ADDRESS addr) {
-	DOUBLE buf;
-	pread64(process_handle, &buf, sizeof(DOUBLE), addr);
-	return buf;
-}
-
-WORD MemoryTool::GetAddressValue_WORD(ADDRESS addr) {
-	WORD buf;
-	pread64(process_handle, &buf, sizeof(WORD), addr);
-	return buf;
-}
-
-BYTE MemoryTool::GetAddressValue_BYTE(ADDRESS addr) {
-	BYTE buf;
-	pread64(process_handle, &buf, sizeof(BYTE), addr);
-	return buf;
-}
-
-QWORD MemoryTool::GetAddressValue_QWORD(ADDRESS addr) {
-	QWORD buf;
-	pread64(process_handle, &buf, sizeof(QWORD), addr);
-	return buf;
-}
-
-char* MemoryTool::GetAddressValue(ADDRESS addr,int type) {
-	char *str = (char *)malloc(sizeof(char));
-	DWORD i;
-	FLOAT f;
-	DOUBLE d;
-	WORD w;
-	BYTE b;
-	QWORD q;
-	switch (type) {
-		case TYPE_DWORD:
-			i = GetAddressValue_DWORD(addr);
-			sprintf(str,"%d",i);
-			break;
-		case TYPE_FLOAT:
-			f = GetAddressValue_FLOAT(addr);
-			sprintf(str,"%e",f);
-			break;
-		case TYPE_DOUBLE:
-			d = GetAddressValue_DOUBLE(addr);
-			sprintf(str,"%e",d);
-			break;
-		case TYPE_WORD:
-			w = GetAddressValue_WORD(addr);
-			sprintf(str,"%d",w);
-			break;
-		case TYPE_BYTE:
-			b = GetAddressValue_BYTE(addr);
-			sprintf(str,"%d",b);
-			break;
-		case TYPE_QWORD:
-			q = GetAddressValue_QWORD(addr);
-			sprintf(str,"%ld",q);
-			break;
-		default:
-			sprintf(str,"%s","");
-			printf("\033[32;1mYou chose an unknown type!\n");
-			break;
-	}
-	return str;
-}
-
-char* MemoryTool::getRightText(char *dst,char *src,int n) {
-	char *p = src;
-	char *q = dst;
-	int len = strlen(src);
-	if(n>len) n=len;
-	p+=(len-n);
-	while(*(q++)=*(p++));
-	return dst;
-}
-
-bool MemoryTool::getMask(long int addr ,char *def) {
-	char *str = (char *)malloc(sizeof(char));
-	sprintf(str,"%lX",addr);
-	char *dest;
-	char* s = getRightText(dest,str,strlen(def));
-	if (strcmp(s, def) == 0) {
-		return true;
-	}
-	return false;
-}
-
-void MemoryTool::MaskSearch(char *def, int type) {
-	PMAPS e, n;
-	e = n = (PMAPS) malloc(LEN);
-	PMAPS pBuff = n;
-	int iCount = 0;
-	PMAPS pTemp = Res;
-	for (int i = 0; i < ResCount; i++) {
-		long int addr = pTemp->addr;
-		bool value = getMask(addr, def);
-		if (value == true) {
-			iCount ++;
-			n->addr = addr;
-			n->type = type;
-			if (iCount == 1) {
-				n->next = NULL;
-				e = n;
-				pBuff = n;
-			} else {
-				n->next = NULL;
-				e->next = n;
-				e = n;
-			}
-			n = (PMAPS) malloc(LEN);
-		}
-		pTemp = pTemp->next;
-	}
-	ResCount = iCount;
-	gs = iCount;
-	Res = pBuff;
-}
-
-int MemoryTool::SetTextColor(COLOR color) {
-	switch (color) {
-		case COLOR_SILVERY:
-			printf("\033[30;1m");
-			break;
-		case COLOR_RED:
-			printf("\033[31;1m");
-			break;
-		case COLOR_GREEN:
-			printf("\033[32;1m");
-			break;
-		case COLOR_YELLOW:
-			printf("\033[33;1m");
-			break;
-		case COLOR_DARK_BLUE:
-			printf("\033[34;1m");
-			break;
-		case COLOR_PINK:
-			printf("\033[35;1m");
-			break;
-		case COLOR_SKY_BLUE:
-			printf("\033[36;1m");
-			break;
-		case COLOR_WHITE:
-			printf("\033[37;1m");
-			break;
-		default:
-			printf("\033[37;1m");
-			break;
-	}
-	return 0;
-}
-
-long int MemoryTool::GetModuleBase(char *module,char * flags,int MapSize) {
-	PMAPS pHead = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pEnd = NULL;
-	pEnd = pNew = (PMAPS) malloc(MapSize);
-	FILE *fp;
-	int flag = 1;
-	char lj[64], buff[256];
-	int pid = getPID(bm);
-	sprintf(lj, "/proc/%d/maps", pid);
-	fp = fopen(lj, "r");
-	if (fp == NULL) {
-		puts("Memory read failed!");
-		return 0;
-	}
-	while (!feof(fp)) {
-		fgets(buff, sizeof(buff), fp);
-		if (strstr(buff, flags) != NULL && !feof(fp) && strstr(buff, module)) {
-			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
-			flag = 1;
-		} else {
-			flag = 0;
-		}
-		if (flag == 1) {
-			pNew->next = NULL;
-			pEnd = pNew;
-			pHead = pNew;
-			pNew = (PMAPS) malloc(MapSize);
-		}
-	}
-	free(pNew);
-	fclose(fp);
-	return pHead->addr;
-}
-
-int MemoryTool::getPID(PACKAGENAME * PackageName) {
-	DIR *dir = NULL;
-	struct dirent *ptr = NULL;
-	FILE *fp = NULL;
-	char filepath[256];
-	char filetext[128];
-	dir = opendir("/proc");
-	if (NULL != dir) {
-		while ((ptr = readdir(dir)) != NULL) {
-			if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0))
-				continue;
-			if (ptr->d_type != DT_DIR)
-				continue;
-			sprintf(filepath, "/proc/%s/cmdline", ptr->d_name);
-			fp = fopen(filepath, "r");
-			if (NULL != fp) {
-				fgets(filetext, sizeof(filetext), fp);
-				if (strcmp(filetext, PackageName) == 0) {
-					// puts(filepath);
-					// printf("packagename:%s\n",filetext);
-					break;
-				}
-				fclose(fp);
-			}
-		}
-	}
-	if (readdir(dir) == NULL) {
-		return 0;
-	}
-	closedir(dir);
-	return atoi(ptr->d_name);
-}
-
-void MemoryTool::PrintResults() {
-	PMAPS temp = Res;
-	const char *type = (char *)malloc(sizeof(char));
-	for (int i = 0; i < ResCount; i++) {
-		switch (temp->type) {
-			case TYPE_DWORD:
-				type = "DWORD";
-				break;
-			case TYPE_FLOAT:
-				type = "FLOAT";
-				break;
-			case TYPE_DOUBLE:
-				type = "DOUBLE";
-				break;
-			case TYPE_WORD:
-				type = "WORD";
-				break;
-			case TYPE_BYTE:
-				type = "BYTE";
-				break;
-			case TYPE_QWORD:
-				type = "QWORD";
-				break;
-			default:
-				type = "";
-				break;
-		}
-
-		printf("\e[37;1mAddr:\e[32;1m0x%lX  \e[37;1mType:\e[36;1m%s\n",temp->addr,type);
-		//printf("addr:\e[32;1m0x%lX type:%s\n", temp->addr,type);
-		temp = temp->next;
-	}
-}
-
-void MemoryTool::ClearResults()	{
-	PMAPS pHead = Res;
-	PMAPS pTemp = pHead;
-	int i;
-	for (i = 0; i < ResCount; i++) {
-		pTemp = pHead;
-		pHead = pHead->next;
-		free(pTemp);
-	}
-}
-
-void MemoryTool::BaseAddressSearch(char *value, TYPE type, ADDRESS BaseAddr) {
-	PMAPS pHead = NULL;
-	PMAPS pMap = NULL;
-	gs = 0;
-	switch (MemorySearchRange) {
-		case ALL:
-			pMap = readmaps(ALL);
-			break;
-		case B_BAD:
-			pMap = readmaps(B_BAD);
-			break;
-		case C_ALLOC:
-			pMap = readmaps(C_ALLOC);
-			break;
-		case C_BSS:
-			pMap = readmaps(C_BSS);
-			break;
-		case C_DATA:
-			pMap = readmaps(C_DATA);
-			break;
-		case C_HEAP:
-			pMap = readmaps(C_HEAP);
-			break;
-		case JAVA_HEAP:
-			pMap = readmaps(JAVA_HEAP);
-			break;
-		case A_ANONMYOUS:
-			pMap = readmaps(A_ANONMYOUS);
-			break;
-		case CODE_SYSTEM:
-			pMap = readmaps(CODE_SYSTEM);
-			break;
-		case STACK:
-			pMap = readmaps(STACK);
-			break;
-		case ASHMEM:
-			pMap = readmaps(ASHMEM);
-			break;
-		default:
-			printf("\033[32;1mYou Select A NULL Type!\n");
-			break;
-	}
-	if (pMap == NULL) {
-		puts("map error");
-		return;
-	}
-	switch (type) {
-		case TYPE_DWORD:
-			pHead = BaseAddressSearch_DWORD(atoi(value), BaseAddr, pMap);
-			break;
-		case TYPE_FLOAT:
-			pHead = BaseAddressSearch_FLOAT(atof(value), BaseAddr, pMap);
-			break;
-		case TYPE_DOUBLE:
-			pHead = BaseAddressSearch_DOUBLE(atof(value), BaseAddr, pMap);
-			break;
-		case TYPE_WORD:
-			pHead = BaseAddressSearch_WORD(atoi(value), BaseAddr, pMap);
-			break;
-		case TYPE_BYTE:
-			pHead = BaseAddressSearch_BYTE(atoi(value), BaseAddr, pMap);
-			break;
-		case TYPE_QWORD:
-			pHead = BaseAddressSearch_QWORD(atoi(value), BaseAddr, pMap);
-			break;
-		default:
-			printf("\033[32;1mYou Select A NULL Type!\n");
-			break;
-	}
-	if (pHead == NULL) {
-        puts("Search memory failed!");
-		return (void)0;
-	}
-	ResCount = gs;
-	Res = pHead;
-}
-
-PMAPS MemoryTool::BaseAddressSearch_DWORD(DWORD value, ADDRESS BaseAddr, PMAPS pMap) {
-	//*gs = 0;
-	// printf("BaseAddress:%lX\n",BaseAddr);
-	PMAPS e, n;
-	e = n = (PMAPS) malloc(LEN);
-	PMAPS pBuff = n;
-	int iCount = 0;
-	long int c, ADDR;
-	void *BUF[8];
-	PMAPS pTemp = pMap;
-	while (pTemp != NULL) {
-		c = (pTemp->taddr - pTemp->addr) / 4096;
-		for (int j = 0; j < c; j++) {
-			ADDR = pTemp->addr + j * 4096 + BaseAddr;
-			pread64(process_handle, BUF, 8, ADDR);
-			if (*(DWORD *)&BUF[0] == value) {
-				iCount++;
-				gs += 1;
-				n->addr = ADDR;
-				n->type = TYPE_DWORD;
-				// printf("addr:%lx,val:%d,buff=%d\n",n->addr,value,buff[i]);
-				if (iCount == 1) {
-					n->next = NULL;
-					e = n;
-					pBuff = n;
-				} else {
-					n->next = NULL;
-					e->next = n;
-					e = n;
-				}
-				n = (PMAPS) malloc(LEN);
-			}
-		}
-		pTemp = pTemp->next;
-	}
-	return pBuff;
-}
-
-PMAPS MemoryTool::BaseAddressSearch_DOUBLE(DOUBLE value, ADDRESS BaseAddr, PMAPS pMap) {
-	//*gs = 0;
-	// printf("BaseAddress:%lX\n",BaseAddr);
-	PMAPS e, n;
-	e = n = (PMAPS) malloc(LEN);
-	PMAPS pBuff = n;
-	int iCount = 0;
-	long int c, ADDR;
-	void *BUF[8];
-	PMAPS pTemp = pMap;
-	while (pTemp != NULL) {
-		c = (pTemp->taddr - pTemp->addr) / 4096;
-		for (int j = 0; j < c; j++) {
-			ADDR = pTemp->addr + j * 4096 + BaseAddr;
-			pread64(process_handle, BUF, 8, ADDR);
-			if (*(DOUBLE *)&BUF[0] == value) {
-				iCount++;
-				gs += 1;
-				n->addr = ADDR;
-				n->type = TYPE_DOUBLE;
-				// printf("addr:%lx,val:%d,buff=%d\n",n->addr,value,buff[i]);
-				if (iCount == 1) {
-					n->next = NULL;
-					e = n;
-					pBuff = n;
-				} else {
-					n->next = NULL;
-					e->next = n;
-					e = n;
-				}
-				n = (PMAPS) malloc(LEN);
-			}
-		}
-		pTemp = pTemp->next;
-	}
-	return pBuff;
-}
-
-PMAPS MemoryTool::BaseAddressSearch_FLOAT(FLOAT value, ADDRESS BaseAddr, PMAPS pMap) {
-	//*gs = 0;
-	PMAPS e, n;
-	e = n = (PMAPS) malloc(LEN);
-	PMAPS pBuff = n;
-	long int c, ADDR;
-	int iCount = 0;
-	void *BUF[8];
-	PMAPS pTemp = pMap;
-	while (pTemp != NULL) {
-		c = (pTemp->taddr - pTemp->addr) / 4096;
-		for (int j = 0; j < c; j++) {
-			ADDR = pTemp->addr + j * 4096 + BaseAddr;
-			pread64(process_handle, BUF, 8, ADDR);
-			if (*(FLOAT *)&BUF[0] == value) {
-				iCount++;
-				gs += 1;
-				n->addr = ADDR;
-				n->type = TYPE_FLOAT;
-				// printf("addr:%lx,val:%d,buff=%d\n",n->addr,value,buff[i]);
-				if (iCount == 1) {
-					n->next = NULL;
-					e = n;
-					pBuff = n;
-				} else {
-					n->next = NULL;
-					e->next = n;
-					e = n;
-				}
-				n = (PMAPS) malloc(LEN);
-			}
-		}
-		pTemp = pTemp->next;
-	}
-	return pBuff;
-}
-
-PMAPS MemoryTool::BaseAddressSearch_WORD(WORD value, ADDRESS BaseAddr, PMAPS pMap) {
-	//*gs = 0;
-	PMAPS e, n;
-	e = n = (PMAPS) malloc(LEN);
-	PMAPS pBuff = n;
-	long int c, ADDR;
-	int iCount = 0;
-	void *BUF[8];
-	PMAPS pTemp = pMap;
-	while (pTemp != NULL) {
-		c = (pTemp->taddr - pTemp->addr) / 4096;
-		for (int j = 0; j < c; j++) {
-			ADDR = pTemp->addr + j * 4096 + BaseAddr;
-			pread64(process_handle, BUF, 8, ADDR);
-			if (*(WORD *)&BUF[0] == value) {
-				iCount++;
-				gs += 1;
-				n->addr = ADDR;
-				n->type = TYPE_WORD;
-				// printf("addr:%lx,val:%d,buff=%d\n",n->addr,value,buff[i]);
-				if (iCount == 1) {
-					n->next = NULL;
-					e = n;
-					pBuff = n;
-				} else {
-					n->next = NULL;
-					e->next = n;
-					e = n;
-				}
-				n = (PMAPS) malloc(LEN);
-			}
-		}
-		pTemp = pTemp->next;
-	}
-	return pBuff;
-}
-
-PMAPS MemoryTool::BaseAddressSearch_QWORD(QWORD value, ADDRESS BaseAddr, PMAPS pMap) {
-	//*gs = 0;
-	PMAPS e, n;
-	e = n = (PMAPS) malloc(LEN);
-	PMAPS pBuff = n;
-	long int c, ADDR;
-	int iCount = 0;
-	void *BUF[8];
-	PMAPS pTemp = pMap;
-	while (pTemp != NULL) {
-		c = (pTemp->taddr - pTemp->addr) / 4096;
-		for (int j = 0; j < c; j++) {
-			ADDR = pTemp->addr + j * 4096 + BaseAddr;
-			pread64(process_handle, BUF, 8, ADDR);
-			if (*(QWORD *)&BUF[0] == value) {
-				iCount++;
-				gs += 1;
-				n->addr = ADDR;
-				n->type = TYPE_QWORD;
-				// printf("addr:%lx,val:%d,buff=%d\n",n->addr,value,buff[i]);
-				if (iCount == 1) {
-					n->next = NULL;
-					e = n;
-					pBuff = n;
-				} else {
-					n->next = NULL;
-					e->next = n;
-					e = n;
-				}
-				n = (PMAPS) malloc(LEN);
-			}
-		}
-		pTemp = pTemp->next;
-	}
-	return pBuff;
-}
-
-PMAPS MemoryTool::BaseAddressSearch_BYTE(BYTE value, ADDRESS BaseAddr, PMAPS pMap) {
-	//*gs = 0;
-	
-	PMAPS e, n;
-	e = n = (PMAPS) malloc(LEN);
-	PMAPS pBuff = n;
-	long int c, ADDR;
-	int iCount = 0;
-	void *BUF[8];
-	PMAPS pTemp = pMap;
-	while (pTemp != NULL) {
-		c = (pTemp->taddr - pTemp->addr) / 4096;
-		for (int j = 0; j < c; j++) {
-			ADDR = pTemp->addr + j * 4096 + BaseAddr;
-			pread64(process_handle, BUF, 8, ADDR);
-			if (*(BYTE *)&BUF[0] == value) {
-				iCount++;
-				gs += 1;
-				n->addr = ADDR;
-				n->type = TYPE_BYTE;
-				// printf("addr:%lx,val:%d,buff=%d\n",n->addr,value,buff[i]);
-				if (iCount == 1) {
-					n->next = NULL;
-					e = n;
-					pBuff = n;
-				} else {
-					n->next = NULL;
-					e->next = n;
-					e = n;
-				}
-				n = (PMAPS) malloc(LEN);
-			}
-		}
-		pTemp = pTemp->next;
-	}
-	return pBuff;
-}
-
-void MemoryTool::RangeMemorySearch(char *from_value, char *to_value, TYPE type) {
-	PMAPS pHead = NULL;
-	PMAPS pMap = NULL;
-	gs = 0;
-	switch (MemorySearchRange) {
-		case ALL:
-			pMap = readmaps(ALL);
-			break;
-		case B_BAD:
-			pMap = readmaps(B_BAD);
-			break;
-		case C_ALLOC:
-			pMap = readmaps(C_ALLOC);
-			break;
-		case C_BSS:
-			pMap = readmaps(C_BSS);
-			break;
-		case C_DATA:
-			pMap = readmaps(C_DATA);
-			break;
-		case C_HEAP:
-			pMap = readmaps(C_HEAP);
-			break;
-		case JAVA_HEAP:
-			pMap = readmaps(JAVA_HEAP);
-			break;
-		case A_ANONMYOUS:
-			pMap = readmaps(A_ANONMYOUS);
-			break;
-		case CODE_SYSTEM:
-			pMap = readmaps(CODE_SYSTEM);
-			break;
-		case STACK:
-			pMap = readmaps(STACK);
-			break;
-		case ASHMEM:
-			pMap = readmaps(ASHMEM);
-			break;
-		default:
-			printf("\033[32;1mYou Select A NULL Type!\n");
-			break;
-	}
-	if (pMap == NULL) {
-		puts("map error");
-		return;
-	}
-	switch (type) {
-		case TYPE_DWORD:
-			if (atoi(from_value) > atoi(to_value))
-				pHead = RangeMemorySearch_DWORD(atoi(to_value), atoi(from_value), pMap);
-			else
-				pHead = RangeMemorySearch_DWORD(atoi(from_value), atoi(to_value), pMap);
-			break;
-		case TYPE_FLOAT:
-			if (atof(from_value) > atof(to_value))
-				pHead = RangeMemorySearch_FLOAT(atof(to_value), atof(from_value), pMap);
-			else
-				pHead = RangeMemorySearch_FLOAT(atof(from_value), atof(to_value), pMap);
-			break;
-		case TYPE_DOUBLE:
-			if (atof(from_value) > atof(to_value))
-				pHead = RangeMemorySearch_DOUBLE(atof(to_value), atof(from_value), pMap);
-			else
-				pHead = RangeMemorySearch_DOUBLE(atof(from_value), atof(to_value), pMap);
-			break;
-		case TYPE_WORD:
-			if (atoi(from_value) > atoi(to_value))
-				pHead = RangeMemorySearch_WORD(atoi(to_value), atoi(from_value), pMap);
-			else
-				pHead = RangeMemorySearch_WORD(atoi(from_value), atoi(to_value), pMap);
-			break;
-		case TYPE_BYTE:
-			if (atoi(from_value) > atoi(to_value))
-				pHead = RangeMemorySearch_BYTE(atoi(to_value), atoi(from_value), pMap);
-			else
-				pHead = RangeMemorySearch_BYTE(atoi(from_value), atoi(to_value), pMap);
-			break;
-		case TYPE_QWORD:
-			if (atoi(from_value) > atoi(to_value))
-				pHead = RangeMemorySearch_QWORD(atoi(to_value), atoi(from_value), pMap);
-			else
-				pHead = RangeMemorySearch_QWORD(atoi(from_value), atoi(to_value), pMap);
-			break;
-		default:
-			printf("\033[32;1mYou Select A NULL Type!\n");
-			break;
-	}
-	if (pHead == NULL) {
-		puts("Range search memory failed!");
-		return;
-	}
-	ResCount = gs;
-	Res = pHead;// Res pointer points to linked list
-}
-
-PMAPS MemoryTool::RangeMemorySearch_DWORD(DWORD from_value, DWORD to_value, PMAPS pMap) {	// DWORD
-	pid_t pid = getPID(bm);
-	if (pid == 0) {
-		puts("Failed to get process!");
-		return NULL;
-	}
-	//*gs = 0;
-	PMAPS pTemp = NULL;
-	pTemp = pMap;
-	PMAPS n, e;
-	e = n = (PMAPS) malloc(LEN);
-	PMAPS pBuff;
-	pBuff = n;
-	int iCount = 0;
-	int c;
-	DWORD buff[1024] = { 0 };
-	memset(buff, 0, 4);
-	while (pTemp != NULL) {
-		c = (pTemp->taddr - pTemp->addr) / 4096;
-		for (int j = 0; j < c; j++) {
-			pread64(process_handle, buff, 0x1000, pTemp->addr + j * 4096);
-			for (int i = 0; i < 1024; i++) {
-				if (buff[i] >= from_value && buff[i] <= to_value) {
-					iCount++;
-					gs += 1;
-					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
-					n->type = TYPE_DWORD;
-					if (iCount == 1) {
-						n->next = NULL;
-						e = n;
-						pBuff = n;
-					} else {
-						n->next = NULL;
-						e->next = n;
-						e = n;
-					}
-					n = (PMAPS) malloc(LEN);
-				}
-			}
-		}
-		pTemp = pTemp->next;
-	}
-	free(n);
-	return pBuff;
-}
-
-PMAPS MemoryTool::RangeMemorySearch_FLOAT(FLOAT from_value, FLOAT to_value, PMAPS pMap) {	// FLOAT
-	pid_t pid = getPID(bm);
-	if (pid == 0) {
-		puts("Failed to get process!");
-		return NULL;
-	}
-	//*gs = 0;
-	PMAPS pTemp = NULL;
-	pTemp = pMap;
-	PMAPS n, e;
-	e = n = (PMAPS) malloc(LEN);
-	PMAPS pBuff;
-	pBuff = n;
-	int iCount = 0;	
-	int c;
-	FLOAT buff[1024] = { 0 };
-	while (pTemp->next != NULL) {
-		c = (pTemp->taddr - pTemp->addr) / 4096;
-		for (int j = 0; j < c; j += 1) {
-			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
-			for (int i = 0; i < 1024; i += 1) {
-				if (buff[i] >= from_value && buff[i] <= to_value) {
-					iCount++;
-					gs += 1;
-					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
-					n->type = TYPE_FLOAT;
-					if (iCount == 1) {
-						n->next = NULL;
-						e = n;
-						pBuff = n;
-					} else {
-						n->next = NULL;
-						e->next = n;
-						e = n;
-					}
-					n = (PMAPS) malloc(LEN);
-				}
-				// printf("buff[%d]=%f\n",l,buff[l]);
-				// usleep(1);
-			}
-			// memset(buff,0,4);
-		}
-		pTemp = pTemp->next;
-	}
-	free(n);
-	return pBuff;
-}
-
-PMAPS MemoryTool::RangeMemorySearch_DOUBLE(DOUBLE from_value, DOUBLE to_value, PMAPS pMap) {	// FLOAT
-	pid_t pid = getPID(bm);
-	if (pid == 0) {
-		puts("Failed to get process!");
-		return NULL;
-	}
-	//*gs = 0;
-	PMAPS pTemp = NULL;
-	pTemp = pMap;
-	PMAPS n, e;
-	e = n = (PMAPS) malloc(LEN);
-	PMAPS pBuff;
-	pBuff = n;
-	int iCount = 0;
-	int c;
-	DOUBLE buff[1024] = { 0 };
-	while (pTemp->next != NULL) {
-		c = (pTemp->taddr - pTemp->addr) / 4096;
-		for (int j = 0; j < c; j += 1) {
-			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
-			for (int i = 0; i < 1024; i += 1) {
-				if (buff[i] >= from_value && buff[i] <= to_value) {
-					iCount++;
-					gs += 1;
-					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
-					n->type = TYPE_DOUBLE;
-					if (iCount == 1) {
-						n->next = NULL;
-						e = n;
-						pBuff = n;
-					} else {
-						n->next = NULL;
-						e->next = n;
-						e = n;
-					}
-					n = (PMAPS) malloc(LEN);
-				}
-				// printf("buff[%d]=%f\n",l,buff[l]);
-				// usleep(1);
-			}
-			// memset(buff,0,4);
-		}
-		pTemp = pTemp->next;
-	}
-	free(n);
-	return pBuff;
-}
-
-PMAPS MemoryTool::RangeMemorySearch_WORD(WORD from_value, WORD to_value, PMAPS pMap) {	// FLOAT
-	pid_t pid = getPID(bm);
-	if (pid == 0) {
-		puts("Failed to get process!");
-		return NULL;
-	}
-	//*gs = 0;
-	PMAPS pTemp = NULL;
-	pTemp = pMap;
-	PMAPS n, e;
-	e = n = (PMAPS) malloc(LEN);
-	PMAPS pBuff;
-	pBuff = n;
-	int iCount = 0;	
-	int c;
-	WORD buff[1024] = { 0 };
-	while (pTemp->next != NULL) {
-		c = (pTemp->taddr - pTemp->addr) / 4096;
-		for (int j = 0; j < c; j += 1) {
-			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
-			for (int i = 0; i < 1024; i += 1) {
-				if (buff[i] >= from_value && buff[i] <= to_value) {
-					iCount++;
-					gs += 1;
-					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
-					n->type = TYPE_WORD;
-					if (iCount == 1) {
-						n->next = NULL;
-						e = n;
-						pBuff = n;
-					} else {
-						n->next = NULL;
-						e->next = n;
-						e = n;
-					}
-					n = (PMAPS) malloc(LEN);
-				}
-				// printf("buff[%d]=%f\n",l,buff[l]);
-				// usleep(1);
-			}
-			// memset(buff,0,4);
-		}
-		pTemp = pTemp->next;
-	}
-	free(n);
-	return pBuff;
-}
-
-PMAPS MemoryTool::RangeMemorySearch_BYTE(BYTE from_value, BYTE to_value, PMAPS pMap) {	// FLOAT
-	pid_t pid = getPID(bm);
-	if (pid == 0) {
-		puts("Failed to get process!");
-		return NULL;
-	}
-	//*gs = 0;
-	PMAPS pTemp = NULL;
-	pTemp = pMap;
-	PMAPS n, e;
-	e = n = (PMAPS) malloc(LEN);
-	PMAPS pBuff;
-	pBuff = n;
-	int iCount = 0;
-	int c;
-	BYTE buff[1024] = { 0 };
-	while (pTemp->next != NULL) {
-		c = (pTemp->taddr - pTemp->addr) / 4096;
-		for (int j = 0; j < c; j += 1) {
-			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
-			for (int i = 0; i < 1024; i += 1) {
-				if (buff[i] >= from_value && buff[i] <= to_value) {
-					iCount++;
-					gs += 1;
-					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
-					n->type = TYPE_BYTE;
-					if (iCount == 1) {
-						n->next = NULL;
-						e = n;
-						pBuff = n;
-					} else {
-						n->next = NULL;
-						e->next = n;
-						e = n;
-					}
-					n = (PMAPS) malloc(LEN);
-				}
-				// printf("buff[%d]=%f\n",l,buff[l]);
-				// usleep(1);
-			}
-			// memset(buff,0,4);
-		}
-		pTemp = pTemp->next;
-	}
-	free(n);
-	return pBuff;
-}
-
-PMAPS MemoryTool::RangeMemorySearch_QWORD(QWORD from_value, QWORD to_value, PMAPS pMap) {	// FLOAT
-	pid_t pid = getPID(bm);
-	if (pid == 0) {
-		puts("Failed to get process!");
-		return NULL;
-	}
-	//*gs = 0;
-	PMAPS pTemp = NULL;
-	pTemp = pMap;
-	PMAPS n, e;
-	e = n = (PMAPS) malloc(LEN);
-	PMAPS pBuff;
-	pBuff = n;
-	int iCount = 0;
-	int c;
-	QWORD buff[1024] = { 0 };
-	while (pTemp->next != NULL) {
-		c = (pTemp->taddr - pTemp->addr) / 4096;
-		for (int j = 0; j < c; j += 1) {
-			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
-			for (int i = 0; i < 1024; i += 1) {
-				if (buff[i] >= from_value && buff[i] <= to_value) {
-					iCount++;
-					gs += 1;
-					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
-					n->type = TYPE_QWORD;
-					if (iCount == 1) {
-						n->next = NULL;
-						e = n;
-						pBuff = n;
-					} else {
-						n->next = NULL;
-						e->next = n;
-						e = n;
-					}
-					n = (PMAPS) malloc(LEN);
-				}
-				// printf("buff[%d]=%f\n",l,buff[l]);
-				// usleep(1);
-			}
-			// memset(buff,0,4);
-		}
-		pTemp = pTemp->next;
-	}
-	free(n);
-	return pBuff;
-}
-
-void MemoryTool::MemorySearch(char *value, TYPE type) {
-	PMAPS pHead = NULL;
-	PMAPS pMap = NULL;
-	gs = 0;
-	switch (MemorySearchRange) {
-		case ALL:
-			pMap = readmaps(ALL);
-			break;
-		case B_BAD:
-			pMap = readmaps(B_BAD);
-			break;
-		case C_ALLOC:
-			pMap = readmaps(C_ALLOC);
-			break;
-		case C_BSS:
-			pMap = readmaps(C_BSS);
-			break;
-		case C_DATA:
-			pMap = readmaps(C_DATA);
-			break;
-		case C_HEAP:
-			pMap = readmaps(C_HEAP);
-			break;
-		case JAVA_HEAP:
-			pMap = readmaps(JAVA_HEAP);
-			break;
-		case A_ANONMYOUS:
-			pMap = readmaps(A_ANONMYOUS);
-			break;
-		case CODE_SYSTEM:
-			pMap = readmaps(CODE_SYSTEM);
-			break;
-		case STACK:
-			pMap = readmaps(STACK);
-			break;
-		case ASHMEM:
-			pMap = readmaps(ASHMEM);
-			break;
-		default:
-			printf("\033[32;1mYou Select A NULL Type!\n");
-			break;
-	}
-	if (pMap == NULL) {
-		puts("map error");
-		return (void)0;
-	}
-	switch (type) {
-		case TYPE_DWORD:
-			pHead = MemorySearch_DWORD(atoi(value), pMap);
-			break;
-		case TYPE_FLOAT:
-			pHead = MemorySearch_FLOAT(atof(value), pMap);
-			break;
-		case TYPE_DOUBLE:
-			pHead = MemorySearch_DOUBLE(atof(value), pMap);
-			break;
-		case TYPE_WORD:
-			pHead = MemorySearch_WORD(atoi(value), pMap);
-			break;
-		case TYPE_BYTE:
-			pHead = MemorySearch_BYTE(atoi(value), pMap);
-			break;
-		case TYPE_QWORD:
-			pHead = MemorySearch_QWORD(atoi(value), pMap);
-			break;
-		default:
-			printf("\033[32;1mYou Select A NULL Type!\n");
-			break;
-	}
-	if (pHead == NULL) {
-		puts("Failed to get process!");
-		return;
-	}
-	ResCount = gs;
-	Res = pHead;
-}
-
-PMAPS MemoryTool::MemorySearch_DWORD(DWORD value, PMAPS pMap) {
-	pid_t pid = getPID(bm);
-	if (pid == 0) {
-		puts("Failed to get process!");
-		return NULL;
-	}
-	//*gs = 0;
-	PMAPS pTemp = NULL;
-	pTemp = pMap;
-	PMAPS n, e;
-	e = n = (PMAPS) malloc(LEN);
-	PMAPS pBuff;
-	pBuff = n;
-	int iCount = 0;
-	int c;
-	DWORD buff[1024] = { 0 };
-	//memset(buff, 0, 4);
-	while (pTemp != NULL) {
-		c = (pTemp->taddr - pTemp->addr) / 4096;
-		for (int j = 0; j < c; j++) {
-			pread64(process_handle, buff, 0x1000, pTemp->addr + j * 4096);
-			for (int i = 0; i < 1024; i++) {
-				if (buff[i] == value) {
-					iCount++;
-					gs += 1;
-					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
-					n->type = TYPE_DWORD;
-					// printf("addr:%lx,val:%d,buff=%d\n",n->addr,value,buff[i]);
-					if (iCount == 1) {
-						n->next = NULL;
-						e = n;
-						pBuff = n;
-					} else {
-						n->next = NULL;
-						e->next = n;
-						e = n;
-					}
-					n = (PMAPS) malloc(LEN);
-				}
-			}
-		}
-		pTemp = pTemp->next;
-	}
-	free(n);
-	return pBuff;
-}
-
-PMAPS MemoryTool::MemorySearch_FLOAT(FLOAT value, PMAPS pMap) {
-	pid_t pid = getPID(bm);
-	if (pid == 0) {
-		puts("Failed to get process!");
-		return NULL;
-	}
-	//*gs = 0;
-	PMAPS pTemp = NULL;
-	pTemp = pMap;
-	PMAPS n, e;
-	e = n = (PMAPS) malloc(LEN);
-	PMAPS pBuff;
-	pBuff = n;
-	int iCount = 0;
-	int c;
-	FLOAT buff[1024] = { 0 };
-	while (pTemp->next != NULL) {
-		c = (pTemp->taddr - pTemp->addr) / 4096;
-		for (int j = 0; j < c; j += 1) {
-			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
-			for (int i = 0; i < 1024; i += 1) {
-				if (buff[i] == value) {
-					iCount++;
-					gs += 1;
-					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
-					n->type = TYPE_FLOAT;
-					if (iCount == 1) {
-						n->next = NULL;
-						e = n;
-						pBuff = n;
-					} else {
-						n->next = NULL;
-						e->next = n;
-						e = n;
-					}
-					n = (PMAPS) malloc(LEN);
-				}
-				// printf("buff[%d]=%f\n",l,buff[l]);
-				// usleep(1);
-			}
-			// memset(buff,0,4);
-		}
-		pTemp = pTemp->next;
-	}
-	free(n);
-	return pBuff;
-}
-
-PMAPS MemoryTool::MemorySearch_DOUBLE(DOUBLE value, PMAPS pMap) {
-	pid_t pid = getPID(bm);
-	if (pid == 0) {
-		puts("Failed to get process!");
-		return NULL;
-	}
-	//*gs = 0;
-	PMAPS pTemp = NULL;
-	pTemp = pMap;
-	PMAPS n, e;
-	e = n = (PMAPS) malloc(LEN);
-	PMAPS pBuff;
-	pBuff = n;
-	int iCount = 0;
-	int c;
-	DOUBLE buff[1024] = { 0 };
-	while (pTemp->next != NULL) {
-		c = (pTemp->taddr - pTemp->addr) / 4096;
-		for (int j = 0; j < c; j += 1) {
-			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
-			for (int i = 0; i < 1024; i += 1) {
-				if (buff[i] == value) {
-					iCount++;
-					gs += 1;
-					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
-					n->type = TYPE_DOUBLE;
-					if (iCount == 1) {
-						n->next = NULL;
-						e = n;
-						pBuff = n;
-					} else {
-						n->next = NULL;
-						e->next = n;
-						e = n;
-					}
-					n = (PMAPS) malloc(LEN);
-				}
-				// printf("buff[%d]=%f\n",l,buff[l]);
-				// usleep(1);
-			}
-			// memset(buff,0,4);
-		}
-		pTemp = pTemp->next;
-	}
-	free(n);
-	return pBuff;
-}
-
-PMAPS MemoryTool::MemorySearch_WORD(WORD value, PMAPS pMap) {
-	pid_t pid = getPID(bm);
-	if (pid == 0) {
-		puts("Failed to get process!");
-		return NULL;
-	}
-	//*gs = 0;
-	PMAPS pTemp = NULL;
-	pTemp = pMap;
-	PMAPS n, e;
-	e = n = (PMAPS) malloc(LEN);
-	PMAPS pBuff;
-	pBuff = n;
-	int iCount = 0;
-	int c;
-	WORD buff[1024] = { 0 };
-	while (pTemp->next != NULL) {
-		c = (pTemp->taddr - pTemp->addr) / 4096;
-		for (int j = 0; j < c; j += 1) {
-			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
-			n->type = TYPE_WORD;
-			for (int i = 0; i < 1024; i += 1) {
-				if (buff[i] == value) {
-					iCount++;
-					gs += 1;
-					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
-					if (iCount == 1) {
-						n->next = NULL;
-						e = n;
-						pBuff = n;
-					} else {
-						n->next = NULL;
-						e->next = n;
-						e = n;
-					}
-					n = (PMAPS) malloc(LEN);
-				}
-				// printf("buff[%d]=%f\n",l,buff[l]);
-				// usleep(1);
-			}
-			// memset(buff,0,4);
-		}
-		pTemp = pTemp->next;
-	}
-	free(n);
-	return pBuff;
-}
-
-PMAPS MemoryTool::MemorySearch_BYTE(BYTE value, PMAPS pMap) {
-	pid_t pid = getPID(bm);
-	if (pid == 0) {
-		puts("Failed to get process!");
-		return NULL;
-	}
-	//*gs = 0;
-	PMAPS pTemp = NULL;
-	pTemp = pMap;
-	PMAPS n, e;
-	e = n = (PMAPS) malloc(LEN);
-	PMAPS pBuff;
-	pBuff = n;
-	int iCount = 0;
-	int c;
-	BYTE buff[1024] = { 0 };
-	while (pTemp->next != NULL) {
-		c = (pTemp->taddr - pTemp->addr) / 4096;
-		for (int j = 0; j < c; j += 1) {
-			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
-			for (int i = 0; i < 1024; i += 1) {
-				if (buff[i] == value) {
-					iCount++;
-					gs += 1;
-					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
-					n->type = TYPE_BYTE;
-					if (iCount == 1) {
-						n->next = NULL;
-						e = n;
-						pBuff = n;
-					} else {
-						n->next = NULL;
-						e->next = n;
-						e = n;
-					}
-					n = (PMAPS) malloc(LEN);
-				}
-				// printf("buff[%d]=%f\n",l,buff[l]);
-				// usleep(1);
-			}
-			// memset(buff,0,4);
-		}
-		pTemp = pTemp->next;
-	}
-	free(n);
-	return pBuff;
-}
-
-PMAPS MemoryTool::MemorySearch_QWORD(QWORD value, PMAPS pMap) {
-	pid_t pid = getPID(bm);
-	if (pid == 0) {
-		puts("Failed to get process!");
-		return NULL;
-	}
-	//*gs = 0;
-	PMAPS pTemp = NULL;
-	pTemp = pMap;
-	PMAPS n, e;
-	e = n = (PMAPS) malloc(LEN);
-	PMAPS pBuff;
-	pBuff = n;
-	int iCount = 0;
-	int c;
-	QWORD buff[1024] = { 0 };
-	while (pTemp->next != NULL) {
-		c = (pTemp->taddr - pTemp->addr) / 4096;
-		for (int j = 0; j < c; j += 1) {
-			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
-			for (int i = 0; i < 1024; i += 1) {
-				if (buff[i] == value) {
-					iCount++;
-					gs += 1;
-					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
-					n->type = TYPE_QWORD;
-					if (iCount == 1) {
-						n->next = NULL;
-						e = n;
-						pBuff = n;
-					} else {
-						n->next = NULL;
-						e->next = n;
-						e = n;
-					}
-					n = (PMAPS) malloc(LEN);
-				}
-				// printf("buff[%d]=%f\n",l,buff[l]);
-				// usleep(1);
-			}
-			// memset(buff,0,4);
-		}
-		pTemp = pTemp->next;
-	}
-	free(n);
-	return pBuff;
-}
-
-void MemoryTool::MemoryOffset(char *value, OFFSET offset, TYPE type) {
-	PMAPS pHead = NULL;
-	gs = 0;
-	switch (type) {
-		case TYPE_DWORD:
-			pHead = MemoryOffset_DWORD(atoi(value), offset, Res);
-			break;
-		case TYPE_FLOAT:
-			pHead = MemoryOffset_FLOAT(atof(value), offset, Res);
-			break;
-		case TYPE_DOUBLE:
-			pHead = MemoryOffset_DOUBLE(atof(value), offset, Res);
-			break;
-		case TYPE_WORD:
-			pHead = MemoryOffset_WORD(atoi(value), offset, Res);
-			break;
-		case TYPE_BYTE:
-			pHead = MemoryOffset_BYTE(atoi(value), offset, Res);
-			break;
-		case TYPE_QWORD:
-			pHead = MemoryOffset_QWORD(atoi(value), offset, Res);
-			break;
-		default:
-			printf("\033[32;1mYou Select A NULL Type!\n");
-			break;
-	}
-	if (pHead == NULL) {
-		puts("Offset failed!");
-		return (void)0;
-	}
-	ResCount = gs;
-	ClearResults();	
-	Res = pHead;
-}
-
-PMAPS MemoryTool::MemoryOffset_DWORD(DWORD value, OFFSET offset, PMAPS pBuff) {
-	
-	//*gs = 0;
-	PMAPS pEnd = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pTemp = pBuff;
-	PMAPS BUFF = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	BUFF = pNew;
-	int iCount = 0;
-	long int all;
-	DWORD *buf = (DWORD *)malloc(sizeof(DWORD));
-	int jg;
-	while (pTemp != NULL) {
-		all = pTemp->addr + offset;
-		pread64(process_handle, buf, 4, all);
-		jg = *buf;
-		if (jg == value) {
-			iCount++;
-			gs += 1;
-			pNew->addr = pTemp->addr;
-			pNew->type = TYPE_DWORD;
-			if (iCount == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				BUFF = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);
-			if (ResCount == 1) {
-				free(pNew);
-				close(process_handle);
-				return BUFF;
-			}
-		}
-		/* else { printf("jg:%d,value:%d\n",jg,value); } */
-		pTemp = pTemp->next;
-	}
-	free(pNew);
-	return BUFF;
-}
-
-PMAPS MemoryTool::MemoryOffset_FLOAT(FLOAT value, OFFSET offset, PMAPS pBuff) {
-	
-	//*gs = 0;
-	PMAPS pEnd = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pTemp = pBuff;
-	PMAPS BUFF = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	BUFF = pNew;
-	int iCount = 0;	
-	long int all;
-	FLOAT *buf = (FLOAT *)malloc(sizeof(FLOAT));
-	// int buf[16];
-	FLOAT jg;
-	while (pTemp != NULL) {
-		all = pTemp->addr + offset;
-		//pread64(process_handle, buf, sizeof(FLOAT), all);
-		pread64(process_handle, buf, 4, all);
-		jg = *buf;
-		if (jg == value) {
-			iCount++;
-			gs += 1;
-			pNew->addr = pTemp->addr;
-			pNew->type = TYPE_FLOAT;
-			if (iCount == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				BUFF = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);
-			if (ResCount == 1) {
-				free(pNew);
-				close(process_handle);
-				return BUFF;
-			}
-		}
-		/* else { printf("jg:%e,value:%e\n",jg,value); } */
-		pTemp = pTemp->next;
-	}
-	free(pNew);
-	return BUFF;
-}
-
-PMAPS MemoryTool::MemoryOffset_DOUBLE(DOUBLE value, OFFSET offset, PMAPS pBuff) {
-	
-	//*gs = 0;
-	PMAPS pEnd = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pTemp = pBuff;
-	PMAPS BUFF = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	BUFF = pNew;
-	int iCount = 0;
-	long int all;
-	DOUBLE *buf = (DOUBLE *)malloc(sizeof(DOUBLE));
-	// int buf[16]; 
-	DOUBLE jg;
-	while (pTemp != NULL) {
-		all = pTemp->addr + offset;
-		pread64(process_handle, buf, 4, all);
-		jg = *buf;
-		if (jg == value) {
-			iCount++;
-			gs += 1;
-			pNew->addr = pTemp->addr;
-			pNew->type = TYPE_DOUBLE;
-			if (iCount == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				BUFF = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);
-			if (ResCount == 1) {
-				free(pNew);
-				close(process_handle);
-				return BUFF;
-			}
-		}
-		/* else { printf("jg:%e,value:%e\n",jg,value); } */
-		pTemp = pTemp->next;
-	}
-	free(pNew);
-	return BUFF;
-}
-
-PMAPS MemoryTool::MemoryOffset_WORD(WORD value, OFFSET offset, PMAPS pBuff) {
-	
-	PMAPS pEnd = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pTemp = pBuff;
-	PMAPS BUFF = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	BUFF = pNew;
-	int iCount = 0;	
-	long int all;			
-	WORD *buf = (WORD *)malloc(sizeof(WORD));
-	WORD jg;
-	while (pTemp != NULL) {
-		all = pTemp->addr + offset;	
-		pread64(process_handle, buf, 4, all);
-		jg = *buf;
-		if (jg == value) {
-			iCount++;
-			gs += 1;
-			pNew->addr = pTemp->addr;
-			pNew->type = TYPE_WORD;
-			if (iCount == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				BUFF = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);
-			if (ResCount == 1) {
-				free(pNew);
-				close(process_handle);
-				return BUFF;
-			}
-		}
-		/* else { printf("jg:%e,value:%e\n",jg,value); } */
-		pTemp = pTemp->next;
-	}
-	free(pNew);
-	return BUFF;
-}
-
-PMAPS MemoryTool::MemoryOffset_BYTE(BYTE value, OFFSET offset, PMAPS pBuff) {
-	
-	PMAPS pEnd = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pTemp = pBuff;
-	PMAPS BUFF = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	BUFF = pNew;
-	int iCount = 0;
-	long int all;
-	BYTE *buf = (BYTE *)malloc(sizeof(BYTE));
-
-	BYTE jg;
-	while (pTemp != NULL) {
-		all = pTemp->addr + offset;
-		pread64(process_handle, buf, 4, all);
-		jg = *buf;
-		if (jg == value) {
-			iCount++;
-			gs += 1;
-			pNew->addr = pTemp->addr;
-			pNew->type = TYPE_BYTE;
-			if (iCount == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				BUFF = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);
-			if (ResCount == 1) {
-				free(pNew);
-				close(process_handle);
-				return BUFF;
-			}
-		}
-		/* else { printf("jg:%e,value:%e\n",jg,value); } */
-		pTemp = pTemp->next;
-	}
-	free(pNew);
-	return BUFF;
-}
-
-PMAPS MemoryTool::MemoryOffset_QWORD(QWORD value, OFFSET offset, PMAPS pBuff) {
-	
-	PMAPS pEnd = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pTemp = pBuff;
-	PMAPS BUFF = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	BUFF = pNew;
-	int iCount = 0;
-	long int all;				
-	QWORD *buf = (QWORD *)malloc(sizeof(QWORD));
-	QWORD jg;
-	while (pTemp != NULL) {
-		all = pTemp->addr + offset;
-		pread64(process_handle, buf, 4, all);
-		jg = *buf;
-		if (jg == value) {
-			iCount++;
-			gs += 1;
-			
-			pNew->addr = pTemp->addr;
-			pNew->type = TYPE_QWORD;
-			if (iCount == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				BUFF = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);
-			if (ResCount == 1) {
-				free(pNew);
-				close(process_handle);
-				return BUFF;
-			}
-		}
-		/* else { printf("jg:%e,value:%e\n",jg,value); } */
-		pTemp = pTemp->next;
-	}
-	free(pNew);
-	return BUFF;
-}
-
-
-void MemoryTool::RangeMemoryOffset(char *from_value, char *to_value, OFFSET offset, TYPE type) {
-	PMAPS pHead = NULL;
-	gs = 0;
-	switch (type) {
-		case TYPE_DWORD:
-			if (atoi(from_value) > atoi(to_value))
-				pHead = RangeMemoryOffset_DWORD(atoi(to_value), atoi(from_value), offset, Res);
-			else
-				pHead = RangeMemoryOffset_DWORD(atoi(from_value), atoi(to_value), offset, Res);
-			break;
-		case TYPE_FLOAT:
-			if (atof(from_value) > atof(to_value))
-				pHead = RangeMemoryOffset_FLOAT(atof(to_value), atof(from_value), offset, Res);
-			else
-				pHead = RangeMemoryOffset_FLOAT(atof(from_value), atof(to_value), offset, Res);
-			break;
-		case TYPE_DOUBLE:
-			if (atof(from_value) > atof(to_value))
-				pHead = RangeMemoryOffset_DOUBLE(atof(to_value), atof(from_value), offset, Res);
-			else
-				pHead = RangeMemoryOffset_DOUBLE(atof(from_value), atof(to_value), offset, Res);
-			break;
-		case TYPE_WORD:
-			if (atoi(from_value) > atoi(to_value))
-				pHead = RangeMemoryOffset_WORD(atoi(to_value), atoi(from_value), offset, Res);
-			else
-				pHead = RangeMemoryOffset_WORD(atoi(from_value), atoi(to_value), offset, Res);
-			break;
-		case TYPE_BYTE:
-			if (atoi(from_value) > atoi(to_value))
-				pHead = RangeMemoryOffset_BYTE(atoi(to_value), atoi(from_value), offset, Res);
-			else
-				pHead = RangeMemoryOffset_BYTE(atoi(from_value), atoi(to_value), offset, Res);
-			break;
-		case TYPE_QWORD:
-			if (atoi(from_value) > atoi(to_value))
-				pHead = RangeMemoryOffset_QWORD(atoi(to_value), atoi(from_value), offset, Res);
-			else
-				pHead = RangeMemoryOffset_QWORD(atoi(from_value), atoi(to_value), offset, Res);
-			break;
-		default:
-			printf("\033[32;1mYou Select A NULL Type!\n");
-			break;
-	}
-	if (pHead == NULL) {
-		puts("Offset failed!");
-		return (void)0;
-	}
-	ResCount = gs;
-	ClearResults();
-	Res = pHead;
-}
-
-PMAPS MemoryTool::RangeMemoryOffset_DWORD(DWORD from_value, DWORD to_value, OFFSET offset, PMAPS pBuff) {
-	
-	//*gs = 0;					
-	PMAPS pEnd = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pTemp = pBuff;
-	PMAPS BUFF = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	BUFF = pNew;
-	int iCount = 0;		
-	long int all;				
-	DWORD *buf = (DWORD *)malloc(sizeof(DWORD));	
-	DWORD jg;
-	while (pTemp != NULL) {
-		all = pTemp->addr + offset;
-		pread64(process_handle, buf, 4, all);
-		jg = *buf;
-		if (jg >= from_value && jg <= to_value) {
-			iCount++;
-			gs += 1;
-			pNew->addr = pTemp->addr;
-			pNew->type = TYPE_DWORD;
-			if (iCount == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				BUFF = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);
-			if (ResCount == 1) {
-				free(pNew);
-				close(process_handle);
-				return BUFF;
-			}
-		}
-		/* else { printf("jg:%d,value:%d\n",jg,value); } */
-		pTemp = pTemp->next;
-	}
-	free(pNew);
-	return BUFF;
-}
-
-PMAPS MemoryTool::RangeMemoryOffset_FLOAT(FLOAT from_value, FLOAT to_value, OFFSET offset, PMAPS pBuff) {
-	
-	//*gs = 0;				
-	PMAPS pEnd = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pTemp = pBuff;
-	PMAPS BUFF = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	BUFF = pNew;
-	int iCount = 0;		
-	long int all;				
-	FLOAT *buf = (FLOAT *)malloc(sizeof(FLOAT));	
-	// int buf[16]; /
-	FLOAT jg;
-	while (pTemp != NULL) {
-		all = pTemp->addr + offset;	
-		pread64(process_handle, buf, 4, all);
-		jg = *buf;
-		if (jg >= from_value && jg <= to_value) {
-			iCount++;
-			gs += 1;
-			pNew->addr = pTemp->addr;
-			pNew->type = TYPE_FLOAT;
-			if (iCount == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				BUFF = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);
-			if (ResCount == 1) {
-				free(pNew);
-				close(process_handle);
-				return BUFF;
-			}
-		}
-		/* else { printf("jg:%e,value:%e\n",jg,value); } */
-		pTemp = pTemp->next;
-	}
-	free(pNew);
-	return BUFF;
-}
-
-PMAPS MemoryTool::RangeMemoryOffset_DOUBLE(DOUBLE from_value, DOUBLE to_value, OFFSET offset, PMAPS pBuff) {
-	
-	//*gs = 0;				
-	PMAPS pEnd = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pTemp = pBuff;
-	PMAPS BUFF = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	BUFF = pNew;
-	int iCount = 0;		
-	long int all;			
-	DOUBLE *buf = (DOUBLE *)malloc(sizeof(DOUBLE));	
-	// int buf[16];
-	DOUBLE jg;
-	while (pTemp != NULL) {
-		all = pTemp->addr + offset;
-		pread64(process_handle, buf, 4, all);
-		jg = *buf;
-		if (jg >= from_value && jg <= to_value) {
-			iCount++;
-			gs += 1;
-			pNew->addr = pTemp->addr;
-			pNew->type = TYPE_DOUBLE;
-			if (iCount == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				BUFF = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);
-			if (ResCount == 1) {
-				free(pNew);
-				close(process_handle);
-				return BUFF;
-			}
-		}
-		/* else { printf("jg:%e,value:%e\n",jg,value); } */
-		pTemp = pTemp->next;
-	}
-	free(pNew);
-	return BUFF;
-}
-
-PMAPS MemoryTool::RangeMemoryOffset_WORD(WORD from_value, WORD to_value, OFFSET offset, PMAPS pBuff) {
-	
-	//*gs = 0;
-	PMAPS pEnd = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pTemp = pBuff;
-	PMAPS BUFF = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	BUFF = pNew;
-	int iCount = 0;		
-	long int all;
-	WORD *buf = (WORD *)malloc(sizeof(WORD));	
-	// int buf[16];
-	WORD jg;
-	while (pTemp != NULL) {
-		all = pTemp->addr + offset;
-		pread64(process_handle, buf, 4, all);
-		jg = *buf;
-		if (jg >= from_value && jg <= to_value) {
-			iCount++;
-			gs += 1;
-			// printf("Modify,addr:%lx\n",all);
-			pNew->addr = pTemp->addr;
-			pNew->type = TYPE_WORD;
-			if (iCount == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				BUFF = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);
-			if (ResCount == 1) {
-				free(pNew);
-				close(process_handle);
-				return BUFF;
-			}
-		}
-		/* else { printf("jg:%e,value:%e\n",jg,value); } */
-		pTemp = pTemp->next;
-	}
-	free(pNew);
-	return BUFF;
-}
-
-PMAPS MemoryTool::RangeMemoryOffset_BYTE(BYTE from_value, BYTE to_value, OFFSET offset, PMAPS pBuff) {
-	
-	//*gs = 0;
-	PMAPS pEnd = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pTemp = pBuff;
-	PMAPS BUFF = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	BUFF = pNew;
-	int iCount = 0;		
-	long int all;				
-	BYTE *buf = (BYTE *)malloc(sizeof(BYTE));	
-	// int buf[16]; 
-	BYTE jg;
-	while (pTemp != NULL) {
-		all = pTemp->addr + offset;	
-		pread64(process_handle, buf, 4, all);
-		jg = *buf;
-		if (jg >= from_value && jg <= to_value) {
-			iCount++;
-			gs += 1;
-			pNew->addr = pTemp->addr;
-			pNew->type = TYPE_BYTE;
-			if (iCount == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				BUFF = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);
-			if (ResCount == 1) {
-				free(pNew);
-				close(process_handle);
-				return BUFF;
-			}
-		}
-		/* else { printf("jg:%e,value:%e\n",jg,value); } */
-		pTemp = pTemp->next;
-	}
-	free(pNew);
-	return BUFF;
-}
-
-PMAPS MemoryTool::RangeMemoryOffset_QWORD(QWORD from_value, QWORD to_value, OFFSET offset, PMAPS pBuff) {
-	
-	//*gs = 0;
-	PMAPS pEnd = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pTemp = pBuff;
-	PMAPS BUFF = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	BUFF = pNew;
-	int iCount = 0;		
-	long int all;				
-	QWORD *buf = (QWORD *)malloc(sizeof(QWORD));	
-	// int buf[16];
-	QWORD jg;
-	while (pTemp != NULL) {
-		all = pTemp->addr + offset;	
-		pread64(process_handle, buf, 4, all);
-		jg = *buf;
-		if (jg >= from_value && jg <= to_value) {
-			iCount++;
-			gs += 1;
-			pNew->addr = pTemp->addr;
-			pNew->type = TYPE_QWORD;
-			if (iCount == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				BUFF = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);
-			if (ResCount == 1) {
-				free(pNew);
-				close(process_handle);
-				return BUFF;
-			}
-		}
-		/* else { printf("jg:%e,value:%e\n",jg,value); } */
-		pTemp = pTemp->next;
-	}
-	free(pNew);
-	return BUFF;
-}
-
-void MemoryTool::MemoryWrite(char *value, OFFSET offset, TYPE type) {
-	switch (type) {
-		case TYPE_DWORD:
-			MemoryWrite_DWORD(atoi(value), Res, offset);
-			break;
-		case TYPE_FLOAT:
-			MemoryWrite_FLOAT(atof(value), Res, offset);
-			break;
-		case TYPE_DOUBLE:
-			MemoryWrite_DOUBLE(atof(value), Res, offset);
-			break;
-		case TYPE_WORD:
-			MemoryWrite_WORD(atoi(value), Res, offset);
-			break;
-		case TYPE_BYTE:
-			MemoryWrite_BYTE(atoi(value), Res, offset);
-			break;
-		case TYPE_QWORD:
-			MemoryWrite_QWORD(atoi(value), Res, offset);
-			break;
-		default:
-			printf("\033[32;1mYou Select A NULL Type!\n");
-			break;
-	}
-	// ClearResults();//cleer list
-}
-int MemoryWrite_DWORD(DWORD value, PMAPS pBuff, OFFSET offset) {
-	
-	PMAPS pTemp = NULL;
-	pTemp = pBuff;
-	int i;
-	for (i = 0; i < ResCount; i++) {
-		pwrite64(process_handle, &value, 4, pTemp->addr + offset);
-		if (pTemp->next != NULL)
-			pTemp = pTemp->next;
-	}
-	return 0;
-}
-
-int MemoryTool::MemoryWrite_FLOAT(FLOAT value, PMAPS pBuff, OFFSET offset) {
-	
-	PMAPS pTemp = NULL;
-	pTemp = pBuff;
-	int i;
-	for (i = 0; i < ResCount; i++) {
-		pwrite64(process_handle, &value, 4, pTemp->addr + offset);
-		if (pTemp->next != NULL)
-			pTemp = pTemp->next;
-	}
-	return 0;
-}
-
-int MemoryTool::MemoryWrite_DOUBLE(DOUBLE value, PMAPS pBuff, OFFSET offset) {
-	
-	PMAPS pTemp = NULL;
-	int process_handle;
-	pTemp = pBuff;
-	int i;
-	for (i = 0; i < ResCount; i++) {
-		pwrite64(process_handle, &value, 4, pTemp->addr + offset);
-		if (pTemp->next != NULL)
-			pTemp = pTemp->next;
-	}
-	return 0;
-}
-
-int MemoryTool::MemoryWrite_WORD(WORD value, PMAPS pBuff, OFFSET offset) {
-	
-	PMAPS pTemp = NULL;
-	pTemp = pBuff;
-	int i;
-	for (i = 0; i < ResCount; i++) {
-		pwrite64(process_handle, &value, 4, pTemp->addr + offset);
-		if (pTemp->next != NULL)
-			pTemp = pTemp->next;
-	}
-	return 0;
-}
-
-int MemoryTool::MemoryWrite_BYTE(BYTE value, PMAPS pBuff, OFFSET offset) {
-	
-	PMAPS pTemp = NULL;
-	pTemp = pBuff;
-	int i;
-	for (i = 0; i < ResCount; i++) {
-		pwrite64(process_handle, &value, 4, pTemp->addr + offset);
-		if (pTemp->next != NULL)
-			pTemp = pTemp->next;
-	}
-	return 0;
-}
-
-int MemoryTool::MemoryWrite_QWORD(QWORD value, PMAPS pBuff, OFFSET offset) {
-	
-	PMAPS pTemp = NULL;
-	pTemp = pBuff;
-	int i;
-	for (i = 0; i < ResCount; i++) {
-		pwrite64(process_handle, &value, 4, pTemp->addr + offset);
-		if (pTemp->next != NULL)
-			pTemp = pTemp->next;
-	}
-	return 0;
-}
-
-int MemoryTool::WriteAddress(ADDRESS addr, char *value, TYPE type) {
-	switch (type) {
-		case TYPE_DWORD:
-			WriteAddress_DWORD(addr, atoi(value));
-			break;
-		case TYPE_FLOAT:
-			WriteAddress_FLOAT(addr, atof(value));
-			break;
-		case TYPE_DOUBLE:
-			WriteAddress_DOUBLE(addr, atof(value));
-			break;
-		case TYPE_WORD:
-			WriteAddress_WORD(addr, atoi(value));
-			break;
-		case TYPE_BYTE:
-			WriteAddress_BYTE(addr, atoi(value));
-			break;
-		case TYPE_QWORD:
-			WriteAddress_QWORD(addr, atoi(value));
-			break;
-		default:
-			printf("\033[32;1mYou Select A NULL Type!\n");
-			break;
-	}
-	return 0;
-}
-
-int MemoryTool::WriteAddress_DWORD(ADDRESS addr, DWORD value) {
-	
-	pwrite64(process_handle, &value, 4, addr);
-	return 0;
-}
-
-int MemoryTool::WriteAddress_FLOAT(ADDRESS addr, FLOAT value) {
-	
-	pwrite64(process_handle, &value, 4, addr);
-	return 0;
-}
-
-int MemoryTool::WriteAddress_DOUBLE(ADDRESS addr, DOUBLE value) {
-	
-	pwrite64(process_handle, &value, 4, addr);
-	return 0;
-}
-
-int MemoryTool::WriteAddress_WORD(ADDRESS addr, WORD value) {
-	
-	pwrite64(process_handle, &value, 4, addr);
-	return 0;
-}
-
-int MemoryTool::WriteAddress_BYTE(ADDRESS addr, BYTE value) {
-	
-	pwrite64(process_handle, &value, 4, addr);
-	return 0;
-}
-
-int MemoryTool::WriteAddress_QWORD(ADDRESS addr, QWORD value) {
-	pwrite64(process_handle, &value, 4, addr);
-	return 0;
-}
-
-int MemoryTool::isapkinstalled(PACKAGENAME * bm) {
-	char LJ[128];
-	sprintf(LJ, "/data/data/%s/", bm);
-	DIR *dir;
-	dir = opendir(LJ);
-	if (dir == NULL) {
-		return 0;
-	} else {
-		return 1;
-	}
-}
-
-int MemoryTool::isapkrunning(PACKAGENAME * bm) {
-	DIR *dir = NULL;
-	struct dirent *ptr = NULL;
-	FILE *fp = NULL;
-	char filepath[50];
-	char filetext[128];
-	dir = opendir("/proc/");	
-	if (dir != NULL) {
-		while ((ptr = readdir(dir)) != NULL) {
-			if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0))
-				continue;
-			if (ptr->d_type != DT_DIR)
-				continue;
-			sprintf(filepath, "/proc/%s/cmdline", ptr->d_name);
-			fp = fopen(filepath, "r");
-			if (NULL != fp) {
-				fgets(filetext, sizeof(filetext), fp);
-				if (strcmp(filetext, bm) == 0) {
-					closedir(dir);
-					return 1;
-				}
-				fclose(fp);
-			}
-		}
-	}
-	closedir(dir);			
-	return 0;
-}
-
-int MemoryTool::uninstallapk(PACKAGENAME * bm) {
-	char ml[128];
-	sprintf(ml, "pm uninstall %s", bm);
-	system(ml);
-	system("clear");
-	return 0;
-}
-
-int MemoryTool::installapk(char *lj) {
-	char ml[128];
-	sprintf(ml, "pm install %s", lj);
-	system(ml);
-	system("clear");
-	return 0;
-}
-
-int MemoryTool::killprocess(PACKAGENAME * bm) {
-	int pid = getPID(bm);
-	if (pid == 0) {
-		return -1;
-	}
-	char ml[32];
-	sprintf(ml, "kill %d", pid);
-	system(ml);					// 杀掉进程
-	return 0;
-}
-
-char MemoryTool::GetProcessState(PACKAGENAME * bm) {
-	/*
-    D uninterruptible sleep state (usually IO processes); R
-    running, in an interruptible queue; S
-    In dormant state, quiescent state; T
-    Stop or be tracked, suspend execution; W
-    into memory swap (not valid since kernel 2.6); X
-    Dead process; Z zombie process does not exist but cannot be eliminated temporarily; W:
-    Not enough memory pages to allocate WCHAN
-    waiting process resource; <: high priority process N:
-    Low priority process L: has memory page allocated and locked in memory
-    (instant system or subject to A I/O), i.e., some pages are locked into memory s
-    the leader of the process (with child processes under it); l
-    multi-process (using CLONE_THREAD, similar to NPTL pthreads); +
-    Process group in the background; */
-
-	int pid = getPID(bm);
-	if (pid == 0) {
-		return 0;
-	}
-	FILE *fp;
-	char lj[64];
-	char buff[64];
-	char zt;
-	char zt1[16];
-	sprintf(lj, "/proc/%d/status", pid);
-	fp = fopen(lj, "r");
-	if (fp == NULL) {
-		return 0;
-	}
-
-	while (!feof(fp)) {
-		fgets(buff, sizeof(buff), fp);
-		if (strstr(buff, "State")) {
-			sscanf(buff, "State: %c", &zt);
-			// printf("state:%c\n",zt);
-			// sleep(1);
-			// puts("emmmm");
-			break;
-		}
-	}
-	// putchar(zt);
-	// puts(zt2);
-	fclose(fp);
-	// puts("loopopp");
-	return zt;
-}
-
-int MemoryTool::rebootsystem() {
-	return system("su -c 'reboot'");
-}
-
-int MemoryTool::PutDate() {
-	return system("date +%F-%T");
-}
-
-int MemoryTool::GetDate(char *date) {
-	FILE *fp;
-	system("date +%F-%T > log.txt");
-	if ((fp = fopen("log.txt", "r")) == NULL) {
-		return 0;
-	}
-	fscanf(fp, "%s", date);	
-	remove("log.txt");
-	return 1;
-}
-
-int MemoryTool::killGG() {
-	// There is a folder named GG-**** in /data/data/[GG modifier package name]/files/
-    // If there is this folder, get the package name mentioned above and kill the GG modifier
-	
-    DIR *dir = NULL;
-	DIR *dirGG = NULL;
-	struct dirent *ptr = NULL;
-	struct dirent *ptrGG = NULL;
-	char filepath[256];			// The size is arbitrary, the path that can install the cmdline file can be
-	char filetext[128];			
-	dir = opendir("/data/data");
-	// puts("killing GG");
-	int flag = 1;
-	if (dir != NULL) {
-		while (flag && (ptr = readdir(dir)) != NULL) {
-			if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0))
-				continue;
-			if (ptr->d_type != DT_DIR)
-				continue;
-			sprintf(filepath, "/data/data/%s/files", ptr->d_name);
-			dirGG = opendir(filepath);
-			if (dirGG != NULL) {
-				while ((ptrGG = readdir(dirGG)) != NULL) {
-					if ((strcmp(ptrGG->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0))
-						continue;
-					if (ptrGG->d_type != DT_DIR)
-						continue;
-					if (strstr(ptrGG->d_name, "GG")) {
-						int pid;	// pid
-						pid = getPID(ptr->d_name);
-						if (pid == 0)	
-							continue;
-						else
-							killprocess(ptr->d_name);
-					}
-				}
-			}
-		}
-	}
-	closedir(dir);	
-	closedir(dirGG);
-	return 0;
-}
-
-int MemoryTool::killXs() {
-	DIR *dir = NULL;
-	struct dirent *ptr = NULL;
-	char filepath[256];
-	char filetext[128];	
-	dir = opendir("/data/data");
-	FILE *fp = NULL;
-	if (NULL != dir) {
-		while ((ptr = readdir(dir)) != NULL) {
-			if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0))
-				continue;
-			if (ptr->d_type != DT_DIR)
-				continue;
-			// /data/data/%s/lib/libxscript.so
-			sprintf(filepath, "/data/data/%s/lib/libxscript.so", ptr->d_name);
-			fp = fopen(filepath, "r");
-			if (fp == NULL)
-				continue;
-			else {
-				killprocess(ptr->d_name);
-			}
-			// killprocess(ptr->d_name);
-		}
-	}
-	closedir(dir);
-	return 0;
-}
-
-void MemoryTool::FreezeThread() {
-	int pid;
-	pid = getPID(bm);
-	if (pid == 0) {
-		puts("Error -1");
-		return;
-	}
-	DWORD buf_i;
-	FLOAT buf_f;
-	DOUBLE buf_d;
-	WORD buf_w;
-	BYTE buf_b;
-	QWORD buf_q;
-	if (process_handle == -1) {
-		puts("Error -2");
-		return;
-	}
-	PFREEZE pTemp = value_freeze;
-	while (Freeze == 1) {
-		pid = getPID(bm);
-		if (pid == 0) {
-			puts("Game is Not Run");
-			exit(1);
-			break;
-		}
-		for (int i = 0; i < FreezeCount; i++) {
-			switch (pTemp->type) {
-				case TYPE_DWORD:
-					buf_i = atoi(pTemp->value);
-					pwrite64(process_handle, &buf_i, 4, pTemp->addr);
-					break;
-				case TYPE_FLOAT:
-					buf_f = atof(pTemp->value);
-					pwrite64(process_handle, &buf_f, 4, pTemp->addr);
-					break;
-				case TYPE_DOUBLE:
-					buf_d = atof(pTemp->value);
-					pwrite64(process_handle, &buf_d, 4, pTemp->addr);
-					break;
-				case TYPE_WORD:
-					buf_w = atoi(pTemp->value);
-					pwrite64(process_handle, &buf_w, 4, pTemp->addr);
-					break;
-				case TYPE_BYTE:
-					buf_b = atoi(pTemp->value);
-					pwrite64(process_handle, &buf_b, 4, pTemp->addr);
-					break;
-				case TYPE_QWORD:
-					buf_q = atoi(pTemp->value);
-					pwrite64(process_handle, &buf_q, 4, pTemp->addr);
-					break;
-				default:
-					break;
-			}
-			pTemp = pTemp->next;
-			usleep(delay);
-		}
-		pTemp = value_freeze;
-	}
-	return;
-}
-
-PMAPS MemoryTool::GetResults() {
-	if (Res == NULL) {
-		return NULL;
-	} else {
-		return Res;	
-	}
-}
-
-int MemoryTool::AddFreezeItem_All(char *Value, TYPE type, OFFSET offset) {
-	if (ResCount == 0) {
-		return -1;
-	}
-	PMAPS pTemp = Res;
-	for (int i = 0; i < ResCount; i++) {
-		switch (type) {
-			case TYPE_DWORD:
-				AddFreezeItem(pTemp->addr, Value, TYPE_DWORD, offset);
-				break;
-			case TYPE_FLOAT:
-				AddFreezeItem(pTemp->addr, Value, TYPE_FLOAT, offset);
-				break;
-			case TYPE_DOUBLE:
-				AddFreezeItem(pTemp->addr, Value, TYPE_DOUBLE, offset);
-				break;
-			case TYPE_WORD:
-				AddFreezeItem(pTemp->addr, Value, TYPE_WORD, offset);
-				break;
-			case TYPE_BYTE:
-				AddFreezeItem(pTemp->addr, Value, TYPE_BYTE, offset);
-				break;
-			case TYPE_QWORD:
-				AddFreezeItem(pTemp->addr, Value, TYPE_QWORD, offset);
-				break;
-			default:
-				SetTextColor(COLOR_SKY_BLUE);
-				puts("You Choose a NULL type");
-				break;
-		}
-		pTemp = pTemp->next;
-	}
-	return 0;
-}
-
-int MemoryTool::AddFreezeItem(ADDRESS addr, char *value, TYPE type, OFFSET offset) {
-	switch (type) {
-		case TYPE_DWORD:
-			AddFreezeItem_DWORD(addr + offset, value);
-			break;
-		case TYPE_FLOAT:
-			AddFreezeItem_FLOAT(addr + offset, value);
-			break;
-		case TYPE_DOUBLE:
-			AddFreezeItem_DOUBLE(addr + offset, value);
-			break;
-		case TYPE_WORD:
-			AddFreezeItem_WORD(addr + offset, value);
-			break;
-		case TYPE_BYTE:
-			AddFreezeItem_BYTE(addr + offset, value);
-			break;
-		case TYPE_QWORD:
-			AddFreezeItem_QWORD(addr + offset, value);
-			break;
-		default:
-			SetTextColor(COLOR_SKY_BLUE);
-			puts("You Choose a NULL type");
-			break;
-	}
-	return 0;
-}
-
-int MemoryTool::AddFreezeItem_DWORD(ADDRESS addr, char *value) {
-	if (FreezeCount == 0) {
-		value_freeze = pEnd = pNew = (PFREEZE) malloc(FRE);
-		pNew->next = NULL;
-		pEnd = pNew;
-		value_freeze = pNew;
-		pNew->addr = addr;
-		pNew->type = TYPE_DWORD;
-		pNew->value = value;
-		FreezeCount += 1;
-	} else {
-		pNew = (PFREEZE) malloc(FRE);
-		pNew->next = NULL;
-		pEnd->next = pNew;
-		pEnd = pNew;
-		pNew->addr = addr;
-		pNew->type = TYPE_DWORD;
-		pNew->value = value;
-		FreezeCount += 1;
-	}
-	return 0;
-}
-
-int MemoryTool::AddFreezeItem_FLOAT(ADDRESS addr, char *value) {
-	if (FreezeCount == 0) {
-		value_freeze = pEnd = pNew = (PFREEZE) malloc(FRE);
-		pNew->next = NULL;
-		pEnd = pNew;
-		value_freeze = pNew;
-		pNew->addr = addr;
-		pNew->type = TYPE_FLOAT;
-		pNew->value = value;
-		FreezeCount += 1;
-	} else {
-		pNew = (PFREEZE) malloc(FRE);
-		pNew->next = NULL;
-		pEnd->next = pNew;
-		pEnd = pNew;
-		pNew->addr = addr;
-		pNew->type = TYPE_FLOAT;
-		pNew->value = value;
-		FreezeCount += 1;
-	}
-	return 0;
-}
-
-int MemoryTool::AddFreezeItem_DOUBLE(ADDRESS addr, char *value) {
-	if (FreezeCount == 0) {
-		value_freeze = pEnd = pNew = (PFREEZE) malloc(FRE);
-		pNew->next = NULL;
-		pEnd = pNew;
-		value_freeze = pNew;
-		pNew->addr = addr;
-		pNew->type = TYPE_DOUBLE;
-		pNew->value = value;
-		FreezeCount += 1;
-	} else {
-		pNew = (PFREEZE) malloc(FRE);
-		pNew->next = NULL;
-		pEnd->next = pNew;
-		pEnd = pNew;
-		pNew->addr = addr;
-		pNew->type = TYPE_DOUBLE;
-		pNew->value = value;
-		FreezeCount += 1;
-	}
-	return 0;
-}
-
-int MemoryTool::AddFreezeItem_WORD(ADDRESS addr, char *value) {
-	if (FreezeCount == 0) {
-		value_freeze = pEnd = pNew = (PFREEZE) malloc(FRE);
-		pNew->next = NULL;
-		pEnd = pNew;
-		value_freeze = pNew;
-		pNew->addr = addr;
-		pNew->type = TYPE_WORD;
-		pNew->value = value;
-		FreezeCount += 1;
-	} else {
-		pNew = (PFREEZE) malloc(FRE);
-		pNew->next = NULL;
-		pEnd->next = pNew;
-		pEnd = pNew;
-		pNew->addr = addr;
-		pNew->type = TYPE_WORD;
-		pNew->value = value;
-		FreezeCount += 1;
-	}
-	return 0;
-}
-
-int MemoryTool::AddFreezeItem_BYTE(ADDRESS addr, char *value) {
-	if (FreezeCount == 0) {
-		value_freeze = pEnd = pNew = (PFREEZE) malloc(FRE);
-		pNew->next = NULL;
-		pEnd = pNew;
-		value_freeze = pNew;
-		pNew->addr = addr;
-		pNew->type = TYPE_BYTE;
-		pNew->value = value;
-		FreezeCount += 1;
-	} else {
-		pNew = (PFREEZE) malloc(FRE);
-		pNew->next = NULL;
-		pEnd->next = pNew;
-		pEnd = pNew;
-		pNew->addr = addr;
-		pNew->type = TYPE_BYTE;
-		pNew->value = value;
-		FreezeCount += 1;
-	}
-	return 0;
-}
-
-int MemoryTool::AddFreezeItem_QWORD(ADDRESS addr, char *value) {
-	if (FreezeCount == 0) {
-		value_freeze = pEnd = pNew = (PFREEZE) malloc(FRE);
-		pNew->next = NULL;
-		pEnd = pNew;
-		value_freeze = pNew;
-		pNew->addr = addr;	
-		pNew->type = TYPE_QWORD;
-		pNew->value = value;
-		FreezeCount += 1;
-	} else {
-		pNew = (PFREEZE) malloc(FRE);
-		pNew->next = NULL;
-		pEnd->next = pNew;
-		pEnd = pNew;
-		pNew->addr = addr;
-		pNew->type = TYPE_QWORD;
-		pNew->value = value;
-		FreezeCount += 1;
-	}
-	return 0;
-}
-
-int MemoryTool::RemoveFreezeItem(ADDRESS addr) {
-	PFREEZE pTemp = value_freeze;
-	PFREEZE p1 = NULL;
-	PFREEZE p2 = NULL;
-	for (int i = 0; i < FreezeCount; i++) {
-		p1 = pTemp;
-		p2 = pTemp->next;
-		if (pTemp->addr == addr) {
-			p1->next = p2;
-			free(pTemp);
-			FreezeCount -= 1;
-			// printf("Freeze count:%d\n",FreezeCount);
-            // break;//Prevent the address from freezing repeatedly, so it is not added, of course, it can also be added
-		}
-		pTemp = p2;
-	}
-	return 0;
-}
-
-int MemoryTool::RemoveFreezeItem_All() {
-	PFREEZE pHead = value_freeze;
-	PFREEZE pTemp = pHead;
-	int i;
-	for (i = 0; i < FreezeCount; i++) {
-		pTemp = pHead;
-		pHead = pHead->next;
-		free(pTemp);
-		FreezeCount -= 1;
-	}
-	free(value_freeze);
-	FreezeCount -= 1;
-	return 0;
-}
-
-int MemoryTool::StartFreeze() {
-	if (Freeze == 1) {
-		return -1;
-	}
-	//int a;
-	//strcpy(Fbm, bm);	
-	Freeze = 1;
-	//pthread_create(&pth, NULL, FreezeThread, NULL);
-	thread th1(&MemoryTool::FreezeThread);
-	//th1.join();
-	return 0;
-}
-
-int MemoryTool::StopFreeze() {
-	Freeze = 0;
-	return 0;
-}
-
-int MemoryTool::SetFreezeDelay(long int De) {
-	delay = De;
-	return 0;
-}
-
-int MemoryTool::PrintFreezeItems() {
-	PFREEZE pTemp = value_freeze;
-	for (int i = 0; i < FreezeCount; i++) {
-		const char *type = (char *)malloc(sizeof(char));
-		switch (pTemp->type) {
-			case TYPE_DWORD:
-				type = "DWORD";
-				break;
-			case TYPE_FLOAT:
-				type = "FLOAT";
-				break;
-			case TYPE_DOUBLE:
-				type = "DOUBLE";
-				break;
-			case TYPE_WORD:
-				type = "WORD";
-				break;
-			case TYPE_BYTE:
-				type = "BYTE";
-				break;
-			case TYPE_QWORD:
-				type = "QWORD";
-				break;
-			default:
-				type = "";
-				break;
-		}
-		printf("FreezeAddr:0x%lX  Type:%s  Value:%s\n",pTemp->addr,type,pTemp->value);
-		pTemp = pTemp->next;
-	}
-	return 0;
-}
-
-
-int MemoryTool::SetSearchRange(TYPE type) {
-	switch (type) {
-		case ALL:
-			MemorySearchRange = 0;
-			break;
-		case B_BAD:
-			MemorySearchRange = 1;
-			break;
-		case C_ALLOC:
-			MemorySearchRange = 2;
-			break;
-		case C_BSS:
-			MemorySearchRange = 3;
-			break;
-		case C_DATA:
-			MemorySearchRange = 4;
-			break;
-		case C_HEAP:
-			MemorySearchRange = 5;
-			break;
-		case JAVA_HEAP:
-			MemorySearchRange = 6;
-			break;
-		case A_ANONMYOUS:
-			MemorySearchRange = 7;
-			break;
-		case CODE_SYSTEM:
-			MemorySearchRange = 8;
-			break;
-		case STACK:
-			MemorySearchRange = 9;
-			break;
-		case ASHMEM:
-			MemorySearchRange = 10;
-			break;
-		default:
-			printf("\033[32;1mYou Select A NULL Type!\n");
-			break;
-	}
-	return 0;
-}
-
-PMAPS MemoryTool::readmaps(TYPE type) {
-	PMAPS pMap = NULL;
-	switch (type) {
-		case ALL:
-			pMap = readmaps_all();
-			break;
-		case B_BAD:
-			pMap = readmaps_bad();
-			break;
-		case C_ALLOC:
-			pMap = readmaps_c_alloc();
-			break;
-		case C_BSS:
-			pMap = readmaps_c_bss();
-			break;
-		case C_DATA:
-			pMap = readmaps_c_data();
-			break;
-		case C_HEAP:
-			pMap = readmaps_c_heap();
-			break;
-		case JAVA_HEAP:
-			pMap = readmaps_java_heap();
-			break;
-		case A_ANONMYOUS:
-			pMap = readmaps_a_anonmyous();
-			break;
-		case CODE_SYSTEM:
-			pMap = readmaps_code_system();
-			break;
-		case STACK:
-			pMap = readmaps_stack();
-			break;
-		case ASHMEM:
-			pMap = readmaps_ashmem();
-			break;
-		default:
-			printf("\033[32;1mYou Select A NULL Type!\n");
-			break;
-	}
-	if (pMap == NULL) {
-		return 0;
-	}
-	return pMap;
-}
-
-PMAPS MemoryTool::readmaps_all() {
-	PMAPS pHead = NULL;
-	PMAPS pNew;
-	PMAPS pEnd;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	FILE *fp;
-	int i = 0, flag = 1;
-	char lj[64], buff[256];
-	int pid = getPID(bm);
-	sprintf(lj, "/proc/%d/maps", pid);
-	fp = fopen(lj, "r");
-	if (fp == NULL) {
-		puts("Memory read failed!");
-		return NULL;
-	}
-	while (!feof(fp)) {
-		fgets(buff, sizeof(buff), fp);
-		if (strstr(buff, "rw") != NULL && !feof(fp)) {
-			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
-			flag = 1;
-		} else {
-			flag = 0;
-		}
-		if (flag == 1) {
-			i++;
-			if (i == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				pHead = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);	
-		}
-	}
-	free(pNew);
-	fclose(fp);
-	return pHead;
-}
-
-PMAPS MemoryTool::readmaps_bad() {
-	PMAPS pHead = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pEnd = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	FILE *fp;
-	int i = 0, flag = 1;
-	char lj[64], buff[256];
-	int pid = getPID(bm);
-	sprintf(lj, "/proc/%d/maps", pid);
-	fp = fopen(lj, "r");
-	if (fp == NULL) {
-		puts("Memory read failed!");
-		return NULL;
-	}
-	while (!feof(fp)) {
-		fgets(buff, sizeof(buff), fp);
-		if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff, "kgsl-3d0")) {
-			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
-			flag = 1;
-		} else {
-			flag = 0;
-		}
-		if (flag == 1) {
-			i++;
-			if (i == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				pHead = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);	
-		}
-	}
-	free(pNew);			
-	fclose(fp);
-	return pHead;
-}
-
-PMAPS MemoryTool::readmaps_c_alloc() {
-	PMAPS pHead = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pEnd = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	FILE *fp;
-	int i = 0, flag = 1;
-	char lj[64], buff[256];
-	int pid = getPID(bm);
-	sprintf(lj, "/proc/%d/maps", pid);
-	fp = fopen(lj, "r");
-	if (fp == NULL) {
-		puts("Memory read failed!");
-		return NULL;
-	}
-	while (!feof(fp)) {
-		fgets(buff, sizeof(buff), fp);	
-		if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff, "[anon:libc_malloc]")) {
-			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
-			flag = 1;
-		} else {
-			flag = 0;
-		}
-		if (flag == 1) {
-			i++;
-			if (i == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				pHead = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);
-		}
-	}
-	free(pNew);				
-	fclose(fp);				
-	return pHead;
-}
-
-PMAPS MemoryTool::readmaps_c_bss() {
-	PMAPS pHead = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pEnd = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	FILE *fp;
-	int i = 0, flag = 1;
-	char lj[64], buff[256];
-	int pid = getPID(bm);
-	sprintf(lj, "/proc/%d/maps", pid);
-	fp = fopen(lj, "r");
-	if (fp == NULL) {
-		puts("Memory read failed!");
-		return NULL;
-	}
-	while (!feof(fp)) {
-		fgets(buff, sizeof(buff), fp);
-		if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff, "[anon:.bss]")) {
-			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
-			flag = 1;
-		} else {
-			flag = 0;
-		}
-		if (flag == 1) {
-			i++;
-			if (i == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				pHead = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);
-		}
-	}
-	free(pNew);				
-	fclose(fp);				
-	return pHead;
-}
-
-PMAPS MemoryTool::readmaps_c_data() {
-	PMAPS pHead = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pEnd = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	FILE *fp;
-	int i = 0, flag = 1;
-	char lj[64], buff[256];
-	int pid = getPID(bm);
-	sprintf(lj, "/proc/%d/maps", pid);
-	fp = fopen(lj, "r");
-	if (fp == NULL) {
-		puts("Memory read failed!");
-		return NULL;
-	}
-	while (!feof(fp)) {
-		fgets(buff, sizeof(buff), fp);
-		if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff, "/data/app/")) {
-			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
-			flag = 1;
-		} else {
-			flag = 0;
-		}
-		if (flag == 1) {
-			i++;
-			if (i == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				pHead = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);
-		}
-	}
-	free(pNew);
-	fclose(fp);	
-	return pHead;
-}
-
-PMAPS MemoryTool::readmaps_c_heap() {
-	PMAPS pHead = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pEnd = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	FILE *fp;
-	int i = 0, flag = 1;
-	char lj[64], buff[256];
-	int pid = getPID(bm);
-	sprintf(lj, "/proc/%d/maps", pid);
-	fp = fopen(lj, "r");
-	if (fp == NULL) {
-		puts("Memory read failed!");
-		return NULL;
-	}
-	while (!feof(fp)) {
-		fgets(buff, sizeof(buff), fp);
-		if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff, "[heap]")) {
-			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
-			flag = 1;
-		} else {
-			flag = 0;
-		}
-		if (flag == 1) {
-			i++;
-			if (i == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				pHead = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);
-		}
-	}
-	free(pNew);				
-	fclose(fp);				
-	return pHead;
-}
-
-PMAPS MemoryTool::readmaps_java_heap() {
-	PMAPS pHead = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pEnd = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	FILE *fp;
-	int i = 0, flag = 1;
-	char lj[64], buff[256];
-	int pid = getPID(bm);
-	sprintf(lj, "/proc/%d/maps", pid);
-	fp = fopen(lj, "r");
-	if (fp == NULL) {
-		puts("Memory read failed!");
-		return NULL;
-	}
-	while (!feof(fp)) {
-		fgets(buff, sizeof(buff), fp);
-		if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff, "/dev/ashmem/")) {
-			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
-			flag = 1;
-		} else {
-			flag = 0;
-		}
-		if (flag == 1) {
-			i++;
-			if (i == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				pHead = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);
-		}
-	}
-	free(pNew);		
-	fclose(fp);				
-	return pHead;
-}
-
-PMAPS MemoryTool::readmaps_a_anonmyous() {
-	PMAPS pHead = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pEnd = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	FILE *fp;
-	int i = 0, flag = 1;
-	char lj[64], buff[256];
-	int pid = getPID(bm);
-	sprintf(lj, "/proc/%d/maps", pid);
-	fp = fopen(lj, "r");
-	if (fp == NULL) {
-		 puts("Memory read failed!");
-		return NULL;
-	}
-	while (!feof(fp)) {
-		fgets(buff, sizeof(buff), fp);
-		if (strstr(buff, "rw") != NULL && !feof(fp) && (strlen(buff) < 42)) {
-			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
-			flag = 1;
-		} else {
-			flag = 0;
-		}
-		if (flag == 1) {
-			i++;
-			if (i == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				pHead = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);	
-		}
-	}
-	free(pNew);			
-	fclose(fp);			
-	return pHead;
-}
-
-PMAPS MemoryTool::readmaps_code_system() {
-	PMAPS pHead = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pEnd = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	FILE *fp;
-	int i = 0, flag = 1;
-	char lj[64], buff[256];
-	int pid = getPID(bm);
-	sprintf(lj, "/proc/%d/maps", pid);
-	fp = fopen(lj, "r");
-	if (fp == NULL) {
-		puts("Memory read failed!");
-		return NULL;
-	}
-	while (!feof(fp)) {
-		fgets(buff, sizeof(buff), fp);
-		if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff, "/system")) {
-			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
-			flag = 1;
-		} else {
-			flag = 0;
-		}
-		if (flag == 1) {
-			i++;
-			if (i == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				pHead = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);	
-		}
-	}
-	free(pNew);				
-	fclose(fp);			
-	return pHead;
-}
-
-PMAPS MemoryTool::readmaps_stack() {
-	PMAPS pHead = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pEnd = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	FILE *fp;
-	int i = 0, flag = 1;
-	char lj[64], buff[256];
-	int pid = getPID(bm);
-	sprintf(lj, "/proc/%d/maps", pid);
-	fp = fopen(lj, "r");
-	if (fp == NULL) {
-		puts("Memory read failed!");
-		return NULL;
-	}
-	while (!feof(fp)) {
-		fgets(buff, sizeof(buff), fp);
-		if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff, "[stack]")) {
-			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
-			flag = 1;
-		} else {
-			flag = 0;
-		}
-		if (flag == 1) {
-			i++;
-			if (i == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				pHead = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);	
-		}
-	}
-	free(pNew);					
-	fclose(fp);				
-	return pHead;
-}
-
-PMAPS MemoryTool::readmaps_ashmem() {
-	PMAPS pHead = NULL;
-	PMAPS pNew = NULL;
-	PMAPS pEnd = NULL;
-	pEnd = pNew = (PMAPS) malloc(LEN);
-	FILE *fp;
-	int i = 0, flag = 1;
-	char lj[64], buff[256];
-	int pid = getPID(bm);
-	sprintf(lj, "/proc/%d/maps", pid);
-	fp = fopen(lj, "r");
-	if (fp == NULL) {
-		puts("Memory read failed!");
-		return NULL;
-	}
-	while (!feof(fp)) {
-		fgets(buff, sizeof(buff), fp);
-		if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff, "/dev/ashmem/")
-		        && !strstr(buff, "dalvik")) {
-			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
-			flag = 1;
-		} else {
-			flag = 0;
-		}
-		if (flag == 1) {
-			i++;
-			if (i == 1) {
-				pNew->next = NULL;
-				pEnd = pNew;
-				pHead = pNew;
-			} else {
-				pNew->next = NULL;
-				pEnd->next = pNew;
-				pEnd = pNew;
-			}
-			pNew = (PMAPS) malloc(LEN);
-		}
-	}
-	free(pNew);	
-	fclose(fp);
-	return pHead;
-}
+#include "MemoryTool.h"
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <thread>
+#include <cstring>
+#include <cstddef>
+#include <cstdint>
+#include <pthread.h>
+
+using namespace std;
+
+void MemoryTool::initXMemoryTools(char* b, char* mode) {
+	strcpy(bm, b);
+	if (strcmp(mode, MODE_ROOT) == 0) {
+		if (getuid() != 0) {
+			system("echo starting");
+			exit(1);
+		}
+	}
+	system("echo 0 > /proc/sys/fs/inotify/max_user_watches");
+	//system("echo 0 > /proc/sys/fs/inotify/max_queued_events");
+	pid_t pid = getPID(b);
+	if (pid == 0) {
+		printf("\033[31;1m");
+		puts("Failed to get process!");
+		exit(1);
+	}
+	char lj[64];
+	sprintf(lj, "/proc/%d/mem", pid);
+	process_handle = open(lj, O_RDWR);
+	if (process_handle == -1) {
+		printf("\033[31;1m");
+		puts("Failed to get mem!");
+		exit(1);
+	}
+	lseek(process_handle, 0, SEEK_SET);
+}
+
+int MemoryTool::GetResultCount() {
+	return gs;
+}
+
+bool MemoryTool::snowpd(long int a2) {
+	return a2 <= 7999 && a2 > 31;
+}
+
+DWORD MemoryTool::GetAddressValue_DWORD(ADDRESS addr) {
+	DWORD buf;
+	pread64(process_handle, &buf, sizeof(DWORD), addr);
+	return buf;
+}
+
+FLOAT MemoryTool::GetAddressValue_FLOAT(ADDRESS addr) {
+	FLOAT buf;
+	pread64(process_handle, &buf, sizeof(FLOAT), addr);
+	return buf;
+}
+
+DOUBLE MemoryTool::GetAddressValue_DOUBLE(ADDRESS addr) {
+	DOUBLE buf;
+	pread64(process_handle, &buf, sizeof(DOUBLE), addr);
+	return buf;
+}
+
+WORD MemoryTool::GetAddressValue_WORD(ADDRESS addr) {
+	WORD buf;
+	pread64(process_handle, &buf, sizeof(WORD), addr);
+	return buf;
+}
+
+BYTE MemoryTool::GetAddressValue_BYTE(ADDRESS addr) {
+	BYTE buf;
+	pread64(process_handle, &buf, sizeof(BYTE), addr);
+	return buf;
+}
+
+QWORD MemoryTool::GetAddressValue_QWORD(ADDRESS addr) {
+	QWORD buf;
+	pread64(process_handle, &buf, sizeof(QWORD), addr);
+	return buf;
+}
+
+char* MemoryTool::GetAddressValue(ADDRESS addr, int type) {
+	char* str = (char*)malloc(sizeof(char));
+	DWORD i;
+	FLOAT f;
+	DOUBLE d;
+	WORD w;
+	BYTE b;
+	QWORD q;
+	switch (type) {
+	case TYPE_DWORD:
+		i = GetAddressValue_DWORD(addr);
+		sprintf(str, "%d", i);
+		break;
+	case TYPE_FLOAT:
+		f = GetAddressValue_FLOAT(addr);
+		sprintf(str, "%e", f);
+		break;
+	case TYPE_DOUBLE:
+		d = GetAddressValue_DOUBLE(addr);
+		sprintf(str, "%e", d);
+		break;
+	case TYPE_WORD:
+		w = GetAddressValue_WORD(addr);
+		sprintf(str, "%d", w);
+		break;
+	case TYPE_BYTE:
+		b = GetAddressValue_BYTE(addr);
+		sprintf(str, "%d", b);
+		break;
+	case TYPE_QWORD:
+		q = GetAddressValue_QWORD(addr);
+		sprintf(str, "%ld", q);
+		break;
+	default:
+		sprintf(str, "%s", "");
+		printf("\033[32;1mYou chose an unknown type!\n");
+		break;
+	}
+	return str;
+}
+
+char* MemoryTool::getRightText(char* dst, char* src, int n) {
+	char* p = src;
+	char* q = dst;
+	int len = strlen(src);
+	if (n > len) n = len;
+	p += (len - n);
+	while (*(q++) = *(p++));
+	return dst;
+}
+
+bool MemoryTool::getMask(long int addr, char* def) {
+	char* str = (char*)malloc(sizeof(char));
+	sprintf(str, "%lX", addr);
+	char* dest;
+	char* s = getRightText(dest, str, strlen(def));
+	if (strcmp(s, def) == 0) {
+		return true;
+	}
+	return false;
+}
+
+void MemoryTool::MaskSearch(char* def, int type) {
+	PMAPS e, n;
+	e = n = (PMAPS)malloc(LEN);
+	PMAPS pBuff = n;
+	int iCount = 0;
+	PMAPS pTemp = Res;
+	for (int i = 0; i < ResCount; i++) {
+		long int addr = pTemp->addr;
+		bool value = getMask(addr, def);
+		if (value == true) {
+			iCount++;
+			n->addr = addr;
+			n->type = type;
+			if (iCount == 1) {
+				n->next = NULL;
+				e = n;
+				pBuff = n;
+			}
+			else {
+				n->next = NULL;
+				e->next = n;
+				e = n;
+			}
+			n = (PMAPS)malloc(LEN);
+		}
+		pTemp = pTemp->next;
+	}
+	ResCount = iCount;
+	gs = iCount;
+	Res = pBuff;
+}
+
+int MemoryTool::SetTextColor(COLOR color) {
+	switch (color) {
+	case COLOR_SILVERY:
+		printf("\033[30;1m");
+		break;
+	case COLOR_RED:
+		printf("\033[31;1m");
+		break;
+	case COLOR_GREEN:
+		printf("\033[32;1m");
+		break;
+	case COLOR_YELLOW:
+		printf("\033[33;1m");
+		break;
+	case COLOR_DARK_BLUE:
+		printf("\033[34;1m");
+		break;
+	case COLOR_PINK:
+		printf("\033[35;1m");
+		break;
+	case COLOR_SKY_BLUE:
+		printf("\033[36;1m");
+		break;
+	case COLOR_WHITE:
+		printf("\033[37;1m");
+		break;
+	default:
+		printf("\033[37;1m");
+		break;
+	}
+	return 0;
+}
+
+long int MemoryTool::GetModuleBase(char* module, char* flags, int MapSize) {
+	PMAPS pHead = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pEnd = NULL;
+	pEnd = pNew = (PMAPS)malloc(MapSize);
+	FILE* fp;
+	int flag = 1;
+	char lj[64], buff[256];
+	int pid = getPID(bm);
+	sprintf(lj, "/proc/%d/maps", pid);
+	fp = fopen(lj, "r");
+	if (fp == NULL) {
+		puts("Memory read failed!");
+		return 0;
+	}
+	while (!feof(fp)) {
+		fgets(buff, sizeof(buff), fp);
+		if (strstr(buff, flags) != NULL && !feof(fp) && strstr(buff, module)) {
+			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
+			flag = 1;
+		}
+		else {
+			flag = 0;
+		}
+		if (flag == 1) {
+			pNew->next = NULL;
+			pEnd = pNew;
+			pHead = pNew;
+			pNew = (PMAPS)malloc(MapSize);
+		}
+	}
+	free(pNew);
+	fclose(fp);
+	return pHead->addr;
+}
+
+int MemoryTool::getPID(PACKAGENAME* PackageName) {
+	DIR* dir = NULL;
+	struct dirent* ptr = NULL;
+	FILE* fp = NULL;
+	char filepath[256];
+	char filetext[128];
+	dir = opendir("/proc");
+	if (NULL != dir) {
+		while ((ptr = readdir(dir)) != NULL) {
+			if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0))
+				continue;
+			if (ptr->d_type != DT_DIR)
+				continue;
+			sprintf(filepath, "/proc/%s/cmdline", ptr->d_name);
+			fp = fopen(filepath, "r");
+			if (NULL != fp) {
+				fgets(filetext, sizeof(filetext), fp);
+				if (strcmp(filetext, PackageName) == 0) {
+					// puts(filepath);
+					// printf("packagename:%s\n",filetext);
+					break;
+				}
+				fclose(fp);
+			}
+		}
+	}
+	if (readdir(dir) == NULL) {
+		return 0;
+	}
+	closedir(dir);
+	return atoi(ptr->d_name);
+}
+
+void MemoryTool::PrintResults() {
+	PMAPS temp = Res;
+	const char* type = (char*)malloc(sizeof(char));
+	for (int i = 0; i < ResCount; i++) {
+		switch (temp->type) {
+		case TYPE_DWORD:
+			type = "DWORD";
+			break;
+		case TYPE_FLOAT:
+			type = "FLOAT";
+			break;
+		case TYPE_DOUBLE:
+			type = "DOUBLE";
+			break;
+		case TYPE_WORD:
+			type = "WORD";
+			break;
+		case TYPE_BYTE:
+			type = "BYTE";
+			break;
+		case TYPE_QWORD:
+			type = "QWORD";
+			break;
+		default:
+			type = "";
+			break;
+		}
+
+		printf("\e[37;1mAddr:\e[32;1m0x%lX  \e[37;1mType:\e[36;1m%s\n", temp->addr, type);
+		//printf("addr:\e[32;1m0x%lX type:%s\n", temp->addr,type);
+		temp = temp->next;
+	}
+}
+
+void MemoryTool::ClearResults() {
+	PMAPS pHead = Res;
+	PMAPS pTemp = pHead;
+	int i;
+	for (i = 0; i < ResCount; i++) {
+		pTemp = pHead;
+		pHead = pHead->next;
+		free(pTemp);
+	}
+}
+
+void MemoryTool::BaseAddressSearch(char* value, TYPE type, ADDRESS BaseAddr) {
+	PMAPS pHead = NULL;
+	PMAPS pMap = NULL;
+	gs = 0;
+	switch (MemorySearchRange) {
+	case ALL:
+		pMap = readmaps(ALL);
+		break;
+	case B_BAD:
+		pMap = readmaps(B_BAD);
+		break;
+	case C_ALLOC:
+		pMap = readmaps(C_ALLOC);
+		break;
+	case C_BSS:
+		pMap = readmaps(C_BSS);
+		break;
+	case C_DATA:
+		pMap = readmaps(C_DATA);
+		break;
+	case C_HEAP:
+		pMap = readmaps(C_HEAP);
+		break;
+	case JAVA_HEAP:
+		pMap = readmaps(JAVA_HEAP);
+		break;
+	case A_ANONMYOUS:
+		pMap = readmaps(A_ANONMYOUS);
+		break;
+	case CODE_SYSTEM:
+		pMap = readmaps(CODE_SYSTEM);
+		break;
+	case STACK:
+		pMap = readmaps(STACK);
+		break;
+	case ASHMEM:
+		pMap = readmaps(ASHMEM);
+		break;
+	default:
+		printf("\033[32;1mYou Select A NULL Type!\n");
+		break;
+	}
+	if (pMap == NULL) {
+		puts("map error");
+		return;
+	}
+	switch (type) {
+	case TYPE_DWORD:
+		pHead = BaseAddressSearch_DWORD(atoi(value), BaseAddr, pMap);
+		break;
+	case TYPE_FLOAT:
+		pHead = BaseAddressSearch_FLOAT(atof(value), BaseAddr, pMap);
+		break;
+	case TYPE_DOUBLE:
+		pHead = BaseAddressSearch_DOUBLE(atof(value), BaseAddr, pMap);
+		break;
+	case TYPE_WORD:
+		pHead = BaseAddressSearch_WORD(atoi(value), BaseAddr, pMap);
+		break;
+	case TYPE_BYTE:
+		pHead = BaseAddressSearch_BYTE(atoi(value), BaseAddr, pMap);
+		break;
+	case TYPE_QWORD:
+		pHead = BaseAddressSearch_QWORD(atoi(value), BaseAddr, pMap);
+		break;
+	default:
+		printf("\033[32;1mYou Select A NULL Type!\n");
+		break;
+	}
+	if (pHead == NULL) {
+		puts("Search memory failed!");
+		return (void)0;
+	}
+	ResCount = gs;
+	Res = pHead;
+}
+
+PMAPS MemoryTool::BaseAddressSearch_DWORD(DWORD value, ADDRESS BaseAddr, PMAPS pMap) {
+	//*gs = 0;
+	// printf("BaseAddress:%lX\n",BaseAddr);
+	PMAPS e, n;
+	e = n = (PMAPS)malloc(LEN);
+	PMAPS pBuff = n;
+	int iCount = 0;
+	long int c, ADDR;
+	void* BUF[8];
+	PMAPS pTemp = pMap;
+	while (pTemp != NULL) {
+		c = (pTemp->taddr - pTemp->addr) / 4096;
+		for (int j = 0; j < c; j++) {
+			ADDR = pTemp->addr + j * 4096 + BaseAddr;
+			pread64(process_handle, BUF, 8, ADDR);
+			if (*(DWORD*)&BUF[0] == value) {
+				iCount++;
+				gs += 1;
+				n->addr = ADDR;
+				n->type = TYPE_DWORD;
+				// printf("addr:%lx,val:%d,buff=%d\n",n->addr,value,buff[i]);
+				if (iCount == 1) {
+					n->next = NULL;
+					e = n;
+					pBuff = n;
+				}
+				else {
+					n->next = NULL;
+					e->next = n;
+					e = n;
+				}
+				n = (PMAPS)malloc(LEN);
+			}
+		}
+		pTemp = pTemp->next;
+	}
+	return pBuff;
+}
+
+PMAPS MemoryTool::BaseAddressSearch_DOUBLE(DOUBLE value, ADDRESS BaseAddr, PMAPS pMap) {
+	//*gs = 0;
+	// printf("BaseAddress:%lX\n",BaseAddr);
+	PMAPS e, n;
+	e = n = (PMAPS)malloc(LEN);
+	PMAPS pBuff = n;
+	int iCount = 0;
+	long int c, ADDR;
+	void* BUF[8];
+	PMAPS pTemp = pMap;
+	while (pTemp != NULL) {
+		c = (pTemp->taddr - pTemp->addr) / 4096;
+		for (int j = 0; j < c; j++) {
+			ADDR = pTemp->addr + j * 4096 + BaseAddr;
+			pread64(process_handle, BUF, 8, ADDR);
+			if (*(DOUBLE*)&BUF[0] == value) {
+				iCount++;
+				gs += 1;
+				n->addr = ADDR;
+				n->type = TYPE_DOUBLE;
+				// printf("addr:%lx,val:%d,buff=%d\n",n->addr,value,buff[i]);
+				if (iCount == 1) {
+					n->next = NULL;
+					e = n;
+					pBuff = n;
+				}
+				else {
+					n->next = NULL;
+					e->next = n;
+					e = n;
+				}
+				n = (PMAPS)malloc(LEN);
+			}
+		}
+		pTemp = pTemp->next;
+	}
+	return pBuff;
+}
+
+PMAPS MemoryTool::BaseAddressSearch_FLOAT(FLOAT value, ADDRESS BaseAddr, PMAPS pMap) {
+	//*gs = 0;
+	PMAPS e, n;
+	e = n = (PMAPS)malloc(LEN);
+	PMAPS pBuff = n;
+	long int c, ADDR;
+	int iCount = 0;
+	void* BUF[8];
+	PMAPS pTemp = pMap;
+	while (pTemp != NULL) {
+		c = (pTemp->taddr - pTemp->addr) / 4096;
+		for (int j = 0; j < c; j++) {
+			ADDR = pTemp->addr + j * 4096 + BaseAddr;
+			pread64(process_handle, BUF, 8, ADDR);
+			if (*(FLOAT*)&BUF[0] == value) {
+				iCount++;
+				gs += 1;
+				n->addr = ADDR;
+				n->type = TYPE_FLOAT;
+				// printf("addr:%lx,val:%d,buff=%d\n",n->addr,value,buff[i]);
+				if (iCount == 1) {
+					n->next = NULL;
+					e = n;
+					pBuff = n;
+				}
+				else {
+					n->next = NULL;
+					e->next = n;
+					e = n;
+				}
+				n = (PMAPS)malloc(LEN);
+			}
+		}
+		pTemp = pTemp->next;
+	}
+	return pBuff;
+}
+
+PMAPS MemoryTool::BaseAddressSearch_WORD(WORD value, ADDRESS BaseAddr, PMAPS pMap) {
+	//*gs = 0;
+	PMAPS e, n;
+	e = n = (PMAPS)malloc(LEN);
+	PMAPS pBuff = n;
+	long int c, ADDR;
+	int iCount = 0;
+	void* BUF[8];
+	PMAPS pTemp = pMap;
+	while (pTemp != NULL) {
+		c = (pTemp->taddr - pTemp->addr) / 4096;
+		for (int j = 0; j < c; j++) {
+			ADDR = pTemp->addr + j * 4096 + BaseAddr;
+			pread64(process_handle, BUF, 8, ADDR);
+			if (*(WORD*)&BUF[0] == value) {
+				iCount++;
+				gs += 1;
+				n->addr = ADDR;
+				n->type = TYPE_WORD;
+				// printf("addr:%lx,val:%d,buff=%d\n",n->addr,value,buff[i]);
+				if (iCount == 1) {
+					n->next = NULL;
+					e = n;
+					pBuff = n;
+				}
+				else {
+					n->next = NULL;
+					e->next = n;
+					e = n;
+				}
+				n = (PMAPS)malloc(LEN);
+			}
+		}
+		pTemp = pTemp->next;
+	}
+	return pBuff;
+}
+
+PMAPS MemoryTool::BaseAddressSearch_QWORD(QWORD value, ADDRESS BaseAddr, PMAPS pMap) {
+	//*gs = 0;
+	PMAPS e, n;
+	e = n = (PMAPS)malloc(LEN);
+	PMAPS pBuff = n;
+	long int c, ADDR;
+	int iCount = 0;
+	void* BUF[8];
+	PMAPS pTemp = pMap;
+	while (pTemp != NULL) {
+		c = (pTemp->taddr - pTemp->addr) / 4096;
+		for (int j = 0; j < c; j++) {
+			ADDR = pTemp->addr + j * 4096 + BaseAddr;
+			pread64(process_handle, BUF, 8, ADDR);
+			if (*(QWORD*)&BUF[0] == value) {
+				iCount++;
+				gs += 1;
+				n->addr = ADDR;
+				n->type = TYPE_QWORD;
+				// printf("addr:%lx,val:%d,buff=%d\n",n->addr,value,buff[i]);
+				if (iCount == 1) {
+					n->next = NULL;
+					e = n;
+					pBuff = n;
+				}
+				else {
+					n->next = NULL;
+					e->next = n;
+					e = n;
+				}
+				n = (PMAPS)malloc(LEN);
+			}
+		}
+		pTemp = pTemp->next;
+	}
+	return pBuff;
+}
+
+PMAPS MemoryTool::BaseAddressSearch_BYTE(BYTE value, ADDRESS BaseAddr, PMAPS pMap) {
+	//*gs = 0;
+
+	PMAPS e, n;
+	e = n = (PMAPS)malloc(LEN);
+	PMAPS pBuff = n;
+	long int c, ADDR;
+	int iCount = 0;
+	void* BUF[8];
+	PMAPS pTemp = pMap;
+	while (pTemp != NULL) {
+		c = (pTemp->taddr - pTemp->addr) / 4096;
+		for (int j = 0; j < c; j++) {
+			ADDR = pTemp->addr + j * 4096 + BaseAddr;
+			pread64(process_handle, BUF, 8, ADDR);
+			if (*(BYTE*)&BUF[0] == value) {
+				iCount++;
+				gs += 1;
+				n->addr = ADDR;
+				n->type = TYPE_BYTE;
+				// printf("addr:%lx,val:%d,buff=%d\n",n->addr,value,buff[i]);
+				if (iCount == 1) {
+					n->next = NULL;
+					e = n;
+					pBuff = n;
+				}
+				else {
+					n->next = NULL;
+					e->next = n;
+					e = n;
+				}
+				n = (PMAPS)malloc(LEN);
+			}
+		}
+		pTemp = pTemp->next;
+	}
+	return pBuff;
+}
+
+void MemoryTool::RangeMemorySearch(char* from_value, char* to_value, TYPE type) {
+	PMAPS pHead = NULL;
+	PMAPS pMap = NULL;
+	gs = 0;
+	switch (MemorySearchRange) {
+	case ALL:
+		pMap = readmaps(ALL);
+		break;
+	case B_BAD:
+		pMap = readmaps(B_BAD);
+		break;
+	case C_ALLOC:
+		pMap = readmaps(C_ALLOC);
+		break;
+	case C_BSS:
+		pMap = readmaps(C_BSS);
+		break;
+	case C_DATA:
+		pMap = readmaps(C_DATA);
+		break;
+	case C_HEAP:
+		pMap = readmaps(C_HEAP);
+		break;
+	case JAVA_HEAP:
+		pMap = readmaps(JAVA_HEAP);
+		break;
+	case A_ANONMYOUS:
+		pMap = readmaps(A_ANONMYOUS);
+		break;
+	case CODE_SYSTEM:
+		pMap = readmaps(CODE_SYSTEM);
+		break;
+	case STACK:
+		pMap = readmaps(STACK);
+		break;
+	case ASHMEM:
+		pMap = readmaps(ASHMEM);
+		break;
+	default:
+		printf("\033[32;1mYou Select A NULL Type!\n");
+		break;
+	}
+	if (pMap == NULL) {
+		puts("map error");
+		return;
+	}
+	switch (type) {
+	case TYPE_DWORD:
+		if (atoi(from_value) > atoi(to_value))
+			pHead = RangeMemorySearch_DWORD(atoi(to_value), atoi(from_value), pMap);
+		else
+			pHead = RangeMemorySearch_DWORD(atoi(from_value), atoi(to_value), pMap);
+		break;
+	case TYPE_FLOAT:
+		if (atof(from_value) > atof(to_value))
+			pHead = RangeMemorySearch_FLOAT(atof(to_value), atof(from_value), pMap);
+		else
+			pHead = RangeMemorySearch_FLOAT(atof(from_value), atof(to_value), pMap);
+		break;
+	case TYPE_DOUBLE:
+		if (atof(from_value) > atof(to_value))
+			pHead = RangeMemorySearch_DOUBLE(atof(to_value), atof(from_value), pMap);
+		else
+			pHead = RangeMemorySearch_DOUBLE(atof(from_value), atof(to_value), pMap);
+		break;
+	case TYPE_WORD:
+		if (atoi(from_value) > atoi(to_value))
+			pHead = RangeMemorySearch_WORD(atoi(to_value), atoi(from_value), pMap);
+		else
+			pHead = RangeMemorySearch_WORD(atoi(from_value), atoi(to_value), pMap);
+		break;
+	case TYPE_BYTE:
+		if (atoi(from_value) > atoi(to_value))
+			pHead = RangeMemorySearch_BYTE(atoi(to_value), atoi(from_value), pMap);
+		else
+			pHead = RangeMemorySearch_BYTE(atoi(from_value), atoi(to_value), pMap);
+		break;
+	case TYPE_QWORD:
+		if (atoi(from_value) > atoi(to_value))
+			pHead = RangeMemorySearch_QWORD(atoi(to_value), atoi(from_value), pMap);
+		else
+			pHead = RangeMemorySearch_QWORD(atoi(from_value), atoi(to_value), pMap);
+		break;
+	default:
+		printf("\033[32;1mYou Select A NULL Type!\n");
+		break;
+	}
+	if (pHead == NULL) {
+		puts("Range search memory failed!");
+		return;
+	}
+	ResCount = gs;
+	Res = pHead;// Res pointer points to linked list
+}
+
+PMAPS MemoryTool::RangeMemorySearch_DWORD(DWORD from_value, DWORD to_value, PMAPS pMap) {	// DWORD
+	pid_t pid = getPID(bm);
+	if (pid == 0) {
+		puts("Failed to get process!");
+		return NULL;
+	}
+	//*gs = 0;
+	PMAPS pTemp = NULL;
+	pTemp = pMap;
+	PMAPS n, e;
+	e = n = (PMAPS)malloc(LEN);
+	PMAPS pBuff;
+	pBuff = n;
+	int iCount = 0;
+	int c;
+	DWORD buff[1024] = { 0 };
+	memset(buff, 0, 4);
+	while (pTemp != NULL) {
+		c = (pTemp->taddr - pTemp->addr) / 4096;
+		for (int j = 0; j < c; j++) {
+			pread64(process_handle, buff, 0x1000, pTemp->addr + j * 4096);
+			for (int i = 0; i < 1024; i++) {
+				if (buff[i] >= from_value && buff[i] <= to_value) {
+					iCount++;
+					gs += 1;
+					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
+					n->type = TYPE_DWORD;
+					if (iCount == 1) {
+						n->next = NULL;
+						e = n;
+						pBuff = n;
+					}
+					else {
+						n->next = NULL;
+						e->next = n;
+						e = n;
+					}
+					n = (PMAPS)malloc(LEN);
+				}
+			}
+		}
+		pTemp = pTemp->next;
+	}
+	free(n);
+	return pBuff;
+}
+
+PMAPS MemoryTool::RangeMemorySearch_FLOAT(FLOAT from_value, FLOAT to_value, PMAPS pMap) {	// FLOAT
+	pid_t pid = getPID(bm);
+	if (pid == 0) {
+		puts("Failed to get process!");
+		return NULL;
+	}
+	//*gs = 0;
+	PMAPS pTemp = NULL;
+	pTemp = pMap;
+	PMAPS n, e;
+	e = n = (PMAPS)malloc(LEN);
+	PMAPS pBuff;
+	pBuff = n;
+	int iCount = 0;
+	int c;
+	FLOAT buff[1024] = { 0 };
+	while (pTemp->next != NULL) {
+		c = (pTemp->taddr - pTemp->addr) / 4096;
+		for (int j = 0; j < c; j += 1) {
+			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
+			for (int i = 0; i < 1024; i += 1) {
+				if (buff[i] >= from_value && buff[i] <= to_value) {
+					iCount++;
+					gs += 1;
+					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
+					n->type = TYPE_FLOAT;
+					if (iCount == 1) {
+						n->next = NULL;
+						e = n;
+						pBuff = n;
+					}
+					else {
+						n->next = NULL;
+						e->next = n;
+						e = n;
+					}
+					n = (PMAPS)malloc(LEN);
+				}
+				// printf("buff[%d]=%f\n",l,buff[l]);
+				// usleep(1);
+			}
+			// memset(buff,0,4);
+		}
+		pTemp = pTemp->next;
+	}
+	free(n);
+	return pBuff;
+}
+
+PMAPS MemoryTool::RangeMemorySearch_DOUBLE(DOUBLE from_value, DOUBLE to_value, PMAPS pMap) {	// FLOAT
+	pid_t pid = getPID(bm);
+	if (pid == 0) {
+		puts("Failed to get process!");
+		return NULL;
+	}
+	//*gs = 0;
+	PMAPS pTemp = NULL;
+	pTemp = pMap;
+	PMAPS n, e;
+	e = n = (PMAPS)malloc(LEN);
+	PMAPS pBuff;
+	pBuff = n;
+	int iCount = 0;
+	int c;
+	DOUBLE buff[1024] = { 0 };
+	while (pTemp->next != NULL) {
+		c = (pTemp->taddr - pTemp->addr) / 4096;
+		for (int j = 0; j < c; j += 1) {
+			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
+			for (int i = 0; i < 1024; i += 1) {
+				if (buff[i] >= from_value && buff[i] <= to_value) {
+					iCount++;
+					gs += 1;
+					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
+					n->type = TYPE_DOUBLE;
+					if (iCount == 1) {
+						n->next = NULL;
+						e = n;
+						pBuff = n;
+					}
+					else {
+						n->next = NULL;
+						e->next = n;
+						e = n;
+					}
+					n = (PMAPS)malloc(LEN);
+				}
+				// printf("buff[%d]=%f\n",l,buff[l]);
+				// usleep(1);
+			}
+			// memset(buff,0,4);
+		}
+		pTemp = pTemp->next;
+	}
+	free(n);
+	return pBuff;
+}
+
+PMAPS MemoryTool::RangeMemorySearch_WORD(WORD from_value, WORD to_value, PMAPS pMap) {	// FLOAT
+	pid_t pid = getPID(bm);
+	if (pid == 0) {
+		puts("Failed to get process!");
+		return NULL;
+	}
+	//*gs = 0;
+	PMAPS pTemp = NULL;
+	pTemp = pMap;
+	PMAPS n, e;
+	e = n = (PMAPS)malloc(LEN);
+	PMAPS pBuff;
+	pBuff = n;
+	int iCount = 0;
+	int c;
+	WORD buff[1024] = { 0 };
+	while (pTemp->next != NULL) {
+		c = (pTemp->taddr - pTemp->addr) / 4096;
+		for (int j = 0; j < c; j += 1) {
+			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
+			for (int i = 0; i < 1024; i += 1) {
+				if (buff[i] >= from_value && buff[i] <= to_value) {
+					iCount++;
+					gs += 1;
+					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
+					n->type = TYPE_WORD;
+					if (iCount == 1) {
+						n->next = NULL;
+						e = n;
+						pBuff = n;
+					}
+					else {
+						n->next = NULL;
+						e->next = n;
+						e = n;
+					}
+					n = (PMAPS)malloc(LEN);
+				}
+				// printf("buff[%d]=%f\n",l,buff[l]);
+				// usleep(1);
+			}
+			// memset(buff,0,4);
+		}
+		pTemp = pTemp->next;
+	}
+	free(n);
+	return pBuff;
+}
+
+PMAPS MemoryTool::RangeMemorySearch_BYTE(BYTE from_value, BYTE to_value, PMAPS pMap) {	// FLOAT
+	pid_t pid = getPID(bm);
+	if (pid == 0) {
+		puts("Failed to get process!");
+		return NULL;
+	}
+	//*gs = 0;
+	PMAPS pTemp = NULL;
+	pTemp = pMap;
+	PMAPS n, e;
+	e = n = (PMAPS)malloc(LEN);
+	PMAPS pBuff;
+	pBuff = n;
+	int iCount = 0;
+	int c;
+	BYTE buff[1024] = { 0 };
+	while (pTemp->next != NULL) {
+		c = (pTemp->taddr - pTemp->addr) / 4096;
+		for (int j = 0; j < c; j += 1) {
+			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
+			for (int i = 0; i < 1024; i += 1) {
+				if (buff[i] >= from_value && buff[i] <= to_value) {
+					iCount++;
+					gs += 1;
+					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
+					n->type = TYPE_BYTE;
+					if (iCount == 1) {
+						n->next = NULL;
+						e = n;
+						pBuff = n;
+					}
+					else {
+						n->next = NULL;
+						e->next = n;
+						e = n;
+					}
+					n = (PMAPS)malloc(LEN);
+				}
+				// printf("buff[%d]=%f\n",l,buff[l]);
+				// usleep(1);
+			}
+			// memset(buff,0,4);
+		}
+		pTemp = pTemp->next;
+	}
+	free(n);
+	return pBuff;
+}
+
+PMAPS MemoryTool::RangeMemorySearch_QWORD(QWORD from_value, QWORD to_value, PMAPS pMap) {	// FLOAT
+	pid_t pid = getPID(bm);
+	if (pid == 0) {
+		puts("Failed to get process!");
+		return NULL;
+	}
+	//*gs = 0;
+	PMAPS pTemp = NULL;
+	pTemp = pMap;
+	PMAPS n, e;
+	e = n = (PMAPS)malloc(LEN);
+	PMAPS pBuff;
+	pBuff = n;
+	int iCount = 0;
+	int c;
+	QWORD buff[1024] = { 0 };
+	while (pTemp->next != NULL) {
+		c = (pTemp->taddr - pTemp->addr) / 4096;
+		for (int j = 0; j < c; j += 1) {
+			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
+			for (int i = 0; i < 1024; i += 1) {
+				if (buff[i] >= from_value && buff[i] <= to_value) {
+					iCount++;
+					gs += 1;
+					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
+					n->type = TYPE_QWORD;
+					if (iCount == 1) {
+						n->next = NULL;
+						e = n;
+						pBuff = n;
+					}
+					else {
+						n->next = NULL;
+						e->next = n;
+						e = n;
+					}
+					n = (PMAPS)malloc(LEN);
+				}
+				// printf("buff[%d]=%f\n",l,buff[l]);
+				// usleep(1);
+			}
+			// memset(buff,0,4);
+		}
+		pTemp = pTemp->next;
+	}
+	free(n);
+	return pBuff;
+}
+
+void MemoryTool::MemorySearch(char* value, TYPE type) {
+	PMAPS pHead = NULL;
+	PMAPS pMap = NULL;
+	gs = 0;
+	switch (MemorySearchRange) {
+	case ALL:
+		pMap = readmaps(ALL);
+		break;
+	case B_BAD:
+		pMap = readmaps(B_BAD);
+		break;
+	case C_ALLOC:
+		pMap = readmaps(C_ALLOC);
+		break;
+	case C_BSS:
+		pMap = readmaps(C_BSS);
+		break;
+	case C_DATA:
+		pMap = readmaps(C_DATA);
+		break;
+	case C_HEAP:
+		pMap = readmaps(C_HEAP);
+		break;
+	case JAVA_HEAP:
+		pMap = readmaps(JAVA_HEAP);
+		break;
+	case A_ANONMYOUS:
+		pMap = readmaps(A_ANONMYOUS);
+		break;
+	case CODE_SYSTEM:
+		pMap = readmaps(CODE_SYSTEM);
+		break;
+	case STACK:
+		pMap = readmaps(STACK);
+		break;
+	case ASHMEM:
+		pMap = readmaps(ASHMEM);
+		break;
+	default:
+		printf("\033[32;1mYou Select A NULL Type!\n");
+		break;
+	}
+	if (pMap == NULL) {
+		puts("map error");
+		return (void)0;
+	}
+	switch (type) {
+	case TYPE_DWORD:
+		pHead = MemorySearch_DWORD(atoi(value), pMap);
+		break;
+	case TYPE_FLOAT:
+		pHead = MemorySearch_FLOAT(atof(value), pMap);
+		break;
+	case TYPE_DOUBLE:
+		pHead = MemorySearch_DOUBLE(atof(value), pMap);
+		break;
+	case TYPE_WORD:
+		pHead = MemorySearch_WORD(atoi(value), pMap);
+		break;
+	case TYPE_BYTE:
+		pHead = MemorySearch_BYTE(atoi(value), pMap);
+		break;
+	case TYPE_QWORD:
+		pHead = MemorySearch_QWORD(atoi(value), pMap);
+		break;
+	default:
+		printf("\033[32;1mYou Select A NULL Type!\n");
+		break;
+	}
+	if (pHead == NULL) {
+		puts("Failed to get process!");
+		return;
+	}
+	ResCount = gs;
+	Res = pHead;
+}
+
+PMAPS MemoryTool::MemorySearch_DWORD(DWORD value, PMAPS pMap) {
+	pid_t pid = getPID(bm);
+	if (pid == 0) {
+		puts("Failed to get process!");
+		return NULL;
+	}
+	//*gs = 0;
+	PMAPS pTemp = NULL;
+	pTemp = pMap;
+	PMAPS n, e;
+	e = n = (PMAPS)malloc(LEN);
+	PMAPS pBuff;
+	pBuff = n;
+	int iCount = 0;
+	int c;
+	DWORD buff[1024] = { 0 };
+	//memset(buff, 0, 4);
+	while (pTemp != NULL) {
+		c = (pTemp->taddr - pTemp->addr) / 4096;
+		for (int j = 0; j < c; j++) {
+			pread64(process_handle, buff, 0x1000, pTemp->addr + j * 4096);
+			for (int i = 0; i < 1024; i++) {
+				if (buff[i] == value) {
+					iCount++;
+					gs += 1;
+					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
+					n->type = TYPE_DWORD;
+					// printf("addr:%lx,val:%d,buff=%d\n",n->addr,value,buff[i]);
+					if (iCount == 1) {
+						n->next = NULL;
+						e = n;
+						pBuff = n;
+					}
+					else {
+						n->next = NULL;
+						e->next = n;
+						e = n;
+					}
+					n = (PMAPS)malloc(LEN);
+				}
+			}
+		}
+		pTemp = pTemp->next;
+	}
+	free(n);
+	return pBuff;
+}
+
+PMAPS MemoryTool::MemorySearch_FLOAT(FLOAT value, PMAPS pMap) {
+	pid_t pid = getPID(bm);
+	if (pid == 0) {
+		puts("Failed to get process!");
+		return NULL;
+	}
+	//*gs = 0;
+	PMAPS pTemp = NULL;
+	pTemp = pMap;
+	PMAPS n, e;
+	e = n = (PMAPS)malloc(LEN);
+	PMAPS pBuff;
+	pBuff = n;
+	int iCount = 0;
+	int c;
+	FLOAT buff[1024] = { 0 };
+	while (pTemp->next != NULL) {
+		c = (pTemp->taddr - pTemp->addr) / 4096;
+		for (int j = 0; j < c; j += 1) {
+			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
+			for (int i = 0; i < 1024; i += 1) {
+				if (buff[i] == value) {
+					iCount++;
+					gs += 1;
+					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
+					n->type = TYPE_FLOAT;
+					if (iCount == 1) {
+						n->next = NULL;
+						e = n;
+						pBuff = n;
+					}
+					else {
+						n->next = NULL;
+						e->next = n;
+						e = n;
+					}
+					n = (PMAPS)malloc(LEN);
+				}
+				// printf("buff[%d]=%f\n",l,buff[l]);
+				// usleep(1);
+			}
+			// memset(buff,0,4);
+		}
+		pTemp = pTemp->next;
+	}
+	free(n);
+	return pBuff;
+}
+
+PMAPS MemoryTool::MemorySearch_DOUBLE(DOUBLE value, PMAPS pMap) {
+	pid_t pid = getPID(bm);
+	if (pid == 0) {
+		puts("Failed to get process!");
+		return NULL;
+	}
+	//*gs = 0;
+	PMAPS pTemp = NULL;
+	pTemp = pMap;
+	PMAPS n, e;
+	e = n = (PMAPS)malloc(LEN);
+	PMAPS pBuff;
+	pBuff = n;
+	int iCount = 0;
+	int c;
+	DOUBLE buff[1024] = { 0 };
+	while (pTemp->next != NULL) {
+		c = (pTemp->taddr - pTemp->addr) / 4096;
+		for (int j = 0; j < c; j += 1) {
+			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
+			for (int i = 0; i < 1024; i += 1) {
+				if (buff[i] == value) {
+					iCount++;
+					gs += 1;
+					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
+					n->type = TYPE_DOUBLE;
+					if (iCount == 1) {
+						n->next = NULL;
+						e = n;
+						pBuff = n;
+					}
+					else {
+						n->next = NULL;
+						e->next = n;
+						e = n;
+					}
+					n = (PMAPS)malloc(LEN);
+				}
+				// printf("buff[%d]=%f\n",l,buff[l]);
+				// usleep(1);
+			}
+			// memset(buff,0,4);
+		}
+		pTemp = pTemp->next;
+	}
+	free(n);
+	return pBuff;
+}
+
+PMAPS MemoryTool::MemorySearch_WORD(WORD value, PMAPS pMap) {
+	pid_t pid = getPID(bm);
+	if (pid == 0) {
+		puts("Failed to get process!");
+		return NULL;
+	}
+	//*gs = 0;
+	PMAPS pTemp = NULL;
+	pTemp = pMap;
+	PMAPS n, e;
+	e = n = (PMAPS)malloc(LEN);
+	PMAPS pBuff;
+	pBuff = n;
+	int iCount = 0;
+	int c;
+	WORD buff[1024] = { 0 };
+	while (pTemp->next != NULL) {
+		c = (pTemp->taddr - pTemp->addr) / 4096;
+		for (int j = 0; j < c; j += 1) {
+			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
+			n->type = TYPE_WORD;
+			for (int i = 0; i < 1024; i += 1) {
+				if (buff[i] == value) {
+					iCount++;
+					gs += 1;
+					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
+					if (iCount == 1) {
+						n->next = NULL;
+						e = n;
+						pBuff = n;
+					}
+					else {
+						n->next = NULL;
+						e->next = n;
+						e = n;
+					}
+					n = (PMAPS)malloc(LEN);
+				}
+				// printf("buff[%d]=%f\n",l,buff[l]);
+				// usleep(1);
+			}
+			// memset(buff,0,4);
+		}
+		pTemp = pTemp->next;
+	}
+	free(n);
+	return pBuff;
+}
+
+PMAPS MemoryTool::MemorySearch_BYTE(BYTE value, PMAPS pMap) {
+	pid_t pid = getPID(bm);
+	if (pid == 0) {
+		puts("Failed to get process!");
+		return NULL;
+	}
+	//*gs = 0;
+	PMAPS pTemp = NULL;
+	pTemp = pMap;
+	PMAPS n, e;
+	e = n = (PMAPS)malloc(LEN);
+	PMAPS pBuff;
+	pBuff = n;
+	int iCount = 0;
+	int c;
+	BYTE buff[1024] = { 0 };
+	while (pTemp->next != NULL) {
+		c = (pTemp->taddr - pTemp->addr) / 4096;
+		for (int j = 0; j < c; j += 1) {
+			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
+			for (int i = 0; i < 1024; i += 1) {
+				if (buff[i] == value) {
+					iCount++;
+					gs += 1;
+					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
+					n->type = TYPE_BYTE;
+					if (iCount == 1) {
+						n->next = NULL;
+						e = n;
+						pBuff = n;
+					}
+					else {
+						n->next = NULL;
+						e->next = n;
+						e = n;
+					}
+					n = (PMAPS)malloc(LEN);
+				}
+				// printf("buff[%d]=%f\n",l,buff[l]);
+				// usleep(1);
+			}
+			// memset(buff,0,4);
+		}
+		pTemp = pTemp->next;
+	}
+	free(n);
+	return pBuff;
+}
+
+PMAPS MemoryTool::MemorySearch_QWORD(QWORD value, PMAPS pMap) {
+	pid_t pid = getPID(bm);
+	if (pid == 0) {
+		puts("Failed to get process!");
+		return NULL;
+	}
+	//*gs = 0;
+	PMAPS pTemp = NULL;
+	pTemp = pMap;
+	PMAPS n, e;
+	e = n = (PMAPS)malloc(LEN);
+	PMAPS pBuff;
+	pBuff = n;
+	int iCount = 0;
+	int c;
+	QWORD buff[1024] = { 0 };
+	while (pTemp->next != NULL) {
+		c = (pTemp->taddr - pTemp->addr) / 4096;
+		for (int j = 0; j < c; j += 1) {
+			pread64(process_handle, buff, 0x1000, pTemp->addr + (j * 4096));
+			for (int i = 0; i < 1024; i += 1) {
+				if (buff[i] == value) {
+					iCount++;
+					gs += 1;
+					n->addr = (pTemp->addr) + (j * 4096) + (i * 4);
+					n->type = TYPE_QWORD;
+					if (iCount == 1) {
+						n->next = NULL;
+						e = n;
+						pBuff = n;
+					}
+					else {
+						n->next = NULL;
+						e->next = n;
+						e = n;
+					}
+					n = (PMAPS)malloc(LEN);
+				}
+				// printf("buff[%d]=%f\n",l,buff[l]);
+				// usleep(1);
+			}
+			// memset(buff,0,4);
+		}
+		pTemp = pTemp->next;
+	}
+	free(n);
+	return pBuff;
+}
+
+void MemoryTool::MemoryOffset(char* value, OFFSET offset, TYPE type) {
+	PMAPS pHead = NULL;
+	gs = 0;
+	switch (type) {
+	case TYPE_DWORD:
+		pHead = MemoryOffset_DWORD(atoi(value), offset, Res);
+		break;
+	case TYPE_FLOAT:
+		pHead = MemoryOffset_FLOAT(atof(value), offset, Res);
+		break;
+	case TYPE_DOUBLE:
+		pHead = MemoryOffset_DOUBLE(atof(value), offset, Res);
+		break;
+	case TYPE_WORD:
+		pHead = MemoryOffset_WORD(atoi(value), offset, Res);
+		break;
+	case TYPE_BYTE:
+		pHead = MemoryOffset_BYTE(atoi(value), offset, Res);
+		break;
+	case TYPE_QWORD:
+		pHead = MemoryOffset_QWORD(atoi(value), offset, Res);
+		break;
+	default:
+		printf("\033[32;1mYou Select A NULL Type!\n");
+		break;
+	}
+	if (pHead == NULL) {
+		puts("Offset failed!");
+		return (void)0;
+	}
+	ResCount = gs;
+	ClearResults();
+	Res = pHead;
+}
+
+PMAPS MemoryTool::MemoryOffset_DWORD(DWORD value, OFFSET offset, PMAPS pBuff) {
+
+	//*gs = 0;
+	PMAPS pEnd = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pTemp = pBuff;
+	PMAPS BUFF = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	BUFF = pNew;
+	int iCount = 0;
+	long int all;
+	DWORD* buf = (DWORD*)malloc(sizeof(DWORD));
+	int jg;
+	while (pTemp != NULL) {
+		all = pTemp->addr + offset;
+		pread64(process_handle, buf, 4, all);
+		jg = *buf;
+		if (jg == value) {
+			iCount++;
+			gs += 1;
+			pNew->addr = pTemp->addr;
+			pNew->type = TYPE_DWORD;
+			if (iCount == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				BUFF = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+			if (ResCount == 1) {
+				free(pNew);
+				close(process_handle);
+				return BUFF;
+			}
+		}
+		/* else { printf("jg:%d,value:%d\n",jg,value); } */
+		pTemp = pTemp->next;
+	}
+	free(pNew);
+	return BUFF;
+}
+
+PMAPS MemoryTool::MemoryOffset_FLOAT(FLOAT value, OFFSET offset, PMAPS pBuff) {
+
+	//*gs = 0;
+	PMAPS pEnd = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pTemp = pBuff;
+	PMAPS BUFF = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	BUFF = pNew;
+	int iCount = 0;
+	long int all;
+	FLOAT* buf = (FLOAT*)malloc(sizeof(FLOAT));
+	// int buf[16];
+	FLOAT jg;
+	while (pTemp != NULL) {
+		all = pTemp->addr + offset;
+		//pread64(process_handle, buf, sizeof(FLOAT), all);
+		pread64(process_handle, buf, 4, all);
+		jg = *buf;
+		if (jg == value) {
+			iCount++;
+			gs += 1;
+			pNew->addr = pTemp->addr;
+			pNew->type = TYPE_FLOAT;
+			if (iCount == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				BUFF = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+			if (ResCount == 1) {
+				free(pNew);
+				close(process_handle);
+				return BUFF;
+			}
+		}
+		/* else { printf("jg:%e,value:%e\n",jg,value); } */
+		pTemp = pTemp->next;
+	}
+	free(pNew);
+	return BUFF;
+}
+
+PMAPS MemoryTool::MemoryOffset_DOUBLE(DOUBLE value, OFFSET offset, PMAPS pBuff) {
+
+	//*gs = 0;
+	PMAPS pEnd = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pTemp = pBuff;
+	PMAPS BUFF = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	BUFF = pNew;
+	int iCount = 0;
+	long int all;
+	DOUBLE* buf = (DOUBLE*)malloc(sizeof(DOUBLE));
+	// int buf[16]; 
+	DOUBLE jg;
+	while (pTemp != NULL) {
+		all = pTemp->addr + offset;
+		pread64(process_handle, buf, 4, all);
+		jg = *buf;
+		if (jg == value) {
+			iCount++;
+			gs += 1;
+			pNew->addr = pTemp->addr;
+			pNew->type = TYPE_DOUBLE;
+			if (iCount == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				BUFF = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+			if (ResCount == 1) {
+				free(pNew);
+				close(process_handle);
+				return BUFF;
+			}
+		}
+		/* else { printf("jg:%e,value:%e\n",jg,value); } */
+		pTemp = pTemp->next;
+	}
+	free(pNew);
+	return BUFF;
+}
+
+PMAPS MemoryTool::MemoryOffset_WORD(WORD value, OFFSET offset, PMAPS pBuff) {
+
+	PMAPS pEnd = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pTemp = pBuff;
+	PMAPS BUFF = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	BUFF = pNew;
+	int iCount = 0;
+	long int all;
+	WORD* buf = (WORD*)malloc(sizeof(WORD));
+	WORD jg;
+	while (pTemp != NULL) {
+		all = pTemp->addr + offset;
+		pread64(process_handle, buf, 4, all);
+		jg = *buf;
+		if (jg == value) {
+			iCount++;
+			gs += 1;
+			pNew->addr = pTemp->addr;
+			pNew->type = TYPE_WORD;
+			if (iCount == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				BUFF = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+			if (ResCount == 1) {
+				free(pNew);
+				close(process_handle);
+				return BUFF;
+			}
+		}
+		/* else { printf("jg:%e,value:%e\n",jg,value); } */
+		pTemp = pTemp->next;
+	}
+	free(pNew);
+	return BUFF;
+}
+
+PMAPS MemoryTool::MemoryOffset_BYTE(BYTE value, OFFSET offset, PMAPS pBuff) {
+
+	PMAPS pEnd = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pTemp = pBuff;
+	PMAPS BUFF = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	BUFF = pNew;
+	int iCount = 0;
+	long int all;
+	BYTE* buf = (BYTE*)malloc(sizeof(BYTE));
+
+	BYTE jg;
+	while (pTemp != NULL) {
+		all = pTemp->addr + offset;
+		pread64(process_handle, buf, 4, all);
+		jg = *buf;
+		if (jg == value) {
+			iCount++;
+			gs += 1;
+			pNew->addr = pTemp->addr;
+			pNew->type = TYPE_BYTE;
+			if (iCount == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				BUFF = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+			if (ResCount == 1) {
+				free(pNew);
+				close(process_handle);
+				return BUFF;
+			}
+		}
+		/* else { printf("jg:%e,value:%e\n",jg,value); } */
+		pTemp = pTemp->next;
+	}
+	free(pNew);
+	return BUFF;
+}
+
+PMAPS MemoryTool::MemoryOffset_QWORD(QWORD value, OFFSET offset, PMAPS pBuff) {
+
+	PMAPS pEnd = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pTemp = pBuff;
+	PMAPS BUFF = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	BUFF = pNew;
+	int iCount = 0;
+	long int all;
+	QWORD* buf = (QWORD*)malloc(sizeof(QWORD));
+	QWORD jg;
+	while (pTemp != NULL) {
+		all = pTemp->addr + offset;
+		pread64(process_handle, buf, 4, all);
+		jg = *buf;
+		if (jg == value) {
+			iCount++;
+			gs += 1;
+
+			pNew->addr = pTemp->addr;
+			pNew->type = TYPE_QWORD;
+			if (iCount == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				BUFF = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+			if (ResCount == 1) {
+				free(pNew);
+				close(process_handle);
+				return BUFF;
+			}
+		}
+		/* else { printf("jg:%e,value:%e\n",jg,value); } */
+		pTemp = pTemp->next;
+	}
+	free(pNew);
+	return BUFF;
+}
+
+
+void MemoryTool::RangeMemoryOffset(char* from_value, char* to_value, OFFSET offset, TYPE type) {
+	PMAPS pHead = NULL;
+	gs = 0;
+	switch (type) {
+	case TYPE_DWORD:
+		if (atoi(from_value) > atoi(to_value))
+			pHead = RangeMemoryOffset_DWORD(atoi(to_value), atoi(from_value), offset, Res);
+		else
+			pHead = RangeMemoryOffset_DWORD(atoi(from_value), atoi(to_value), offset, Res);
+		break;
+	case TYPE_FLOAT:
+		if (atof(from_value) > atof(to_value))
+			pHead = RangeMemoryOffset_FLOAT(atof(to_value), atof(from_value), offset, Res);
+		else
+			pHead = RangeMemoryOffset_FLOAT(atof(from_value), atof(to_value), offset, Res);
+		break;
+	case TYPE_DOUBLE:
+		if (atof(from_value) > atof(to_value))
+			pHead = RangeMemoryOffset_DOUBLE(atof(to_value), atof(from_value), offset, Res);
+		else
+			pHead = RangeMemoryOffset_DOUBLE(atof(from_value), atof(to_value), offset, Res);
+		break;
+	case TYPE_WORD:
+		if (atoi(from_value) > atoi(to_value))
+			pHead = RangeMemoryOffset_WORD(atoi(to_value), atoi(from_value), offset, Res);
+		else
+			pHead = RangeMemoryOffset_WORD(atoi(from_value), atoi(to_value), offset, Res);
+		break;
+	case TYPE_BYTE:
+		if (atoi(from_value) > atoi(to_value))
+			pHead = RangeMemoryOffset_BYTE(atoi(to_value), atoi(from_value), offset, Res);
+		else
+			pHead = RangeMemoryOffset_BYTE(atoi(from_value), atoi(to_value), offset, Res);
+		break;
+	case TYPE_QWORD:
+		if (atoi(from_value) > atoi(to_value))
+			pHead = RangeMemoryOffset_QWORD(atoi(to_value), atoi(from_value), offset, Res);
+		else
+			pHead = RangeMemoryOffset_QWORD(atoi(from_value), atoi(to_value), offset, Res);
+		break;
+	default:
+		printf("\033[32;1mYou Select A NULL Type!\n");
+		break;
+	}
+	if (pHead == NULL) {
+		puts("Offset failed!");
+		return (void)0;
+	}
+	ResCount = gs;
+	ClearResults();
+	Res = pHead;
+}
+
+PMAPS MemoryTool::RangeMemoryOffset_DWORD(DWORD from_value, DWORD to_value, OFFSET offset, PMAPS pBuff) {
+
+	//*gs = 0;					
+	PMAPS pEnd = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pTemp = pBuff;
+	PMAPS BUFF = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	BUFF = pNew;
+	int iCount = 0;
+	long int all;
+	DWORD* buf = (DWORD*)malloc(sizeof(DWORD));
+	DWORD jg;
+	while (pTemp != NULL) {
+		all = pTemp->addr + offset;
+		pread64(process_handle, buf, 4, all);
+		jg = *buf;
+		if (jg >= from_value && jg <= to_value) {
+			iCount++;
+			gs += 1;
+			pNew->addr = pTemp->addr;
+			pNew->type = TYPE_DWORD;
+			if (iCount == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				BUFF = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+			if (ResCount == 1) {
+				free(pNew);
+				close(process_handle);
+				return BUFF;
+			}
+		}
+		/* else { printf("jg:%d,value:%d\n",jg,value); } */
+		pTemp = pTemp->next;
+	}
+	free(pNew);
+	return BUFF;
+}
+
+PMAPS MemoryTool::RangeMemoryOffset_FLOAT(FLOAT from_value, FLOAT to_value, OFFSET offset, PMAPS pBuff) {
+
+	//*gs = 0;				
+	PMAPS pEnd = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pTemp = pBuff;
+	PMAPS BUFF = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	BUFF = pNew;
+	int iCount = 0;
+	long int all;
+	FLOAT* buf = (FLOAT*)malloc(sizeof(FLOAT));
+	// int buf[16]; /
+	FLOAT jg;
+	while (pTemp != NULL) {
+		all = pTemp->addr + offset;
+		pread64(process_handle, buf, 4, all);
+		jg = *buf;
+		if (jg >= from_value && jg <= to_value) {
+			iCount++;
+			gs += 1;
+			pNew->addr = pTemp->addr;
+			pNew->type = TYPE_FLOAT;
+			if (iCount == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				BUFF = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+			if (ResCount == 1) {
+				free(pNew);
+				close(process_handle);
+				return BUFF;
+			}
+		}
+		/* else { printf("jg:%e,value:%e\n",jg,value); } */
+		pTemp = pTemp->next;
+	}
+	free(pNew);
+	return BUFF;
+}
+
+PMAPS MemoryTool::RangeMemoryOffset_DOUBLE(DOUBLE from_value, DOUBLE to_value, OFFSET offset, PMAPS pBuff) {
+
+	//*gs = 0;				
+	PMAPS pEnd = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pTemp = pBuff;
+	PMAPS BUFF = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	BUFF = pNew;
+	int iCount = 0;
+	long int all;
+	DOUBLE* buf = (DOUBLE*)malloc(sizeof(DOUBLE));
+	// int buf[16];
+	DOUBLE jg;
+	while (pTemp != NULL) {
+		all = pTemp->addr + offset;
+		pread64(process_handle, buf, 4, all);
+		jg = *buf;
+		if (jg >= from_value && jg <= to_value) {
+			iCount++;
+			gs += 1;
+			pNew->addr = pTemp->addr;
+			pNew->type = TYPE_DOUBLE;
+			if (iCount == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				BUFF = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+			if (ResCount == 1) {
+				free(pNew);
+				close(process_handle);
+				return BUFF;
+			}
+		}
+		/* else { printf("jg:%e,value:%e\n",jg,value); } */
+		pTemp = pTemp->next;
+	}
+	free(pNew);
+	return BUFF;
+}
+
+PMAPS MemoryTool::RangeMemoryOffset_WORD(WORD from_value, WORD to_value, OFFSET offset, PMAPS pBuff) {
+
+	//*gs = 0;
+	PMAPS pEnd = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pTemp = pBuff;
+	PMAPS BUFF = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	BUFF = pNew;
+	int iCount = 0;
+	long int all;
+	WORD* buf = (WORD*)malloc(sizeof(WORD));
+	// int buf[16];
+	WORD jg;
+	while (pTemp != NULL) {
+		all = pTemp->addr + offset;
+		pread64(process_handle, buf, 4, all);
+		jg = *buf;
+		if (jg >= from_value && jg <= to_value) {
+			iCount++;
+			gs += 1;
+			// printf("Modify,addr:%lx\n",all);
+			pNew->addr = pTemp->addr;
+			pNew->type = TYPE_WORD;
+			if (iCount == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				BUFF = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+			if (ResCount == 1) {
+				free(pNew);
+				close(process_handle);
+				return BUFF;
+			}
+		}
+		/* else { printf("jg:%e,value:%e\n",jg,value); } */
+		pTemp = pTemp->next;
+	}
+	free(pNew);
+	return BUFF;
+}
+
+PMAPS MemoryTool::RangeMemoryOffset_BYTE(BYTE from_value, BYTE to_value, OFFSET offset, PMAPS pBuff) {
+
+	//*gs = 0;
+	PMAPS pEnd = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pTemp = pBuff;
+	PMAPS BUFF = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	BUFF = pNew;
+	int iCount = 0;
+	long int all;
+	BYTE* buf = (BYTE*)malloc(sizeof(BYTE));
+	// int buf[16]; 
+	BYTE jg;
+	while (pTemp != NULL) {
+		all = pTemp->addr + offset;
+		pread64(process_handle, buf, 4, all);
+		jg = *buf;
+		if (jg >= from_value && jg <= to_value) {
+			iCount++;
+			gs += 1;
+			pNew->addr = pTemp->addr;
+			pNew->type = TYPE_BYTE;
+			if (iCount == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				BUFF = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+			if (ResCount == 1) {
+				free(pNew);
+				close(process_handle);
+				return BUFF;
+			}
+		}
+		/* else { printf("jg:%e,value:%e\n",jg,value); } */
+		pTemp = pTemp->next;
+	}
+	free(pNew);
+	return BUFF;
+}
+
+PMAPS MemoryTool::RangeMemoryOffset_QWORD(QWORD from_value, QWORD to_value, OFFSET offset, PMAPS pBuff) {
+
+	//*gs = 0;
+	PMAPS pEnd = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pTemp = pBuff;
+	PMAPS BUFF = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	BUFF = pNew;
+	int iCount = 0;
+	long int all;
+	QWORD* buf = (QWORD*)malloc(sizeof(QWORD));
+	// int buf[16];
+	QWORD jg;
+	while (pTemp != NULL) {
+		all = pTemp->addr + offset;
+		pread64(process_handle, buf, 4, all);
+		jg = *buf;
+		if (jg >= from_value && jg <= to_value) {
+			iCount++;
+			gs += 1;
+			pNew->addr = pTemp->addr;
+			pNew->type = TYPE_QWORD;
+			if (iCount == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				BUFF = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+			if (ResCount == 1) {
+				free(pNew);
+				close(process_handle);
+				return BUFF;
+			}
+		}
+		/* else { printf("jg:%e,value:%e\n",jg,value); } */
+		pTemp = pTemp->next;
+	}
+	free(pNew);
+	return BUFF;
+}
+
+void MemoryTool::MemoryWrite(char* value, OFFSET offset, TYPE type) {
+	switch (type) {
+	case TYPE_DWORD:
+		MemoryWrite_DWORD(atoi(value), Res, offset);
+		break;
+	case TYPE_FLOAT:
+		MemoryWrite_FLOAT(atof(value), Res, offset);
+		break;
+	case TYPE_DOUBLE:
+		MemoryWrite_DOUBLE(atof(value), Res, offset);
+		break;
+	case TYPE_WORD:
+		MemoryWrite_WORD(atoi(value), Res, offset);
+		break;
+	case TYPE_BYTE:
+		MemoryWrite_BYTE(atoi(value), Res, offset);
+		break;
+	case TYPE_QWORD:
+		MemoryWrite_QWORD(atoi(value), Res, offset);
+		break;
+	default:
+		printf("\033[32;1mYou Select A NULL Type!\n");
+		break;
+	}
+	// ClearResults();//cleer list
+}
+int MemoryTool::MemoryWrite_DWORD(DWORD value, PMAPS pBuff, OFFSET offset) {
+
+	PMAPS pTemp = NULL;
+	pTemp = pBuff;
+	int i;
+	for (i = 0; i < ResCount; i++) {
+		pwrite64(process_handle, &value, 4, pTemp->addr + offset);
+		if (pTemp->next != NULL)
+			pTemp = pTemp->next;
+	}
+	return 0;
+}
+
+int MemoryTool::MemoryWrite_FLOAT(FLOAT value, PMAPS pBuff, OFFSET offset) {
+
+	PMAPS pTemp = NULL;
+	pTemp = pBuff;
+	int i;
+	for (i = 0; i < ResCount; i++) {
+		pwrite64(process_handle, &value, 4, pTemp->addr + offset);
+		if (pTemp->next != NULL)
+			pTemp = pTemp->next;
+	}
+	return 0;
+}
+
+int MemoryTool::MemoryWrite_DOUBLE(DOUBLE value, PMAPS pBuff, OFFSET offset) {
+
+	PMAPS pTemp = NULL;
+	int process_handle;
+	pTemp = pBuff;
+	int i;
+	for (i = 0; i < ResCount; i++) {
+		pwrite64(process_handle, &value, 4, pTemp->addr + offset);
+		if (pTemp->next != NULL)
+			pTemp = pTemp->next;
+	}
+	return 0;
+}
+
+int MemoryTool::MemoryWrite_WORD(WORD value, PMAPS pBuff, OFFSET offset) {
+
+	PMAPS pTemp = NULL;
+	pTemp = pBuff;
+	int i;
+	for (i = 0; i < ResCount; i++) {
+		pwrite64(process_handle, &value, 4, pTemp->addr + offset);
+		if (pTemp->next != NULL)
+			pTemp = pTemp->next;
+	}
+	return 0;
+}
+
+int MemoryTool::MemoryWrite_BYTE(BYTE value, PMAPS pBuff, OFFSET offset) {
+
+	PMAPS pTemp = NULL;
+	pTemp = pBuff;
+	int i;
+	for (i = 0; i < ResCount; i++) {
+		pwrite64(process_handle, &value, 4, pTemp->addr + offset);
+		if (pTemp->next != NULL)
+			pTemp = pTemp->next;
+	}
+	return 0;
+}
+
+int MemoryTool::MemoryWrite_QWORD(QWORD value, PMAPS pBuff, OFFSET offset) {
+
+	PMAPS pTemp = NULL;
+	pTemp = pBuff;
+	int i;
+	for (i = 0; i < ResCount; i++) {
+		pwrite64(process_handle, &value, 4, pTemp->addr + offset);
+		if (pTemp->next != NULL)
+			pTemp = pTemp->next;
+	}
+	return 0;
+}
+
+int MemoryTool::WriteAddress(ADDRESS addr, char* value, TYPE type) {
+	switch (type) {
+	case TYPE_DWORD:
+		WriteAddress_DWORD(addr, atoi(value));
+		break;
+	case TYPE_FLOAT:
+		WriteAddress_FLOAT(addr, atof(value));
+		break;
+	case TYPE_DOUBLE:
+		WriteAddress_DOUBLE(addr, atof(value));
+		break;
+	case TYPE_WORD:
+		WriteAddress_WORD(addr, atoi(value));
+		break;
+	case TYPE_BYTE:
+		WriteAddress_BYTE(addr, atoi(value));
+		break;
+	case TYPE_QWORD:
+		WriteAddress_QWORD(addr, atoi(value));
+		break;
+	default:
+		printf("\033[32;1mYou Select A NULL Type!\n");
+		break;
+	}
+	return 0;
+}
+
+int MemoryTool::WriteAddress_DWORD(ADDRESS addr, DWORD value) {
+
+	pwrite64(process_handle, &value, 4, addr);
+	return 0;
+}
+
+int MemoryTool::WriteAddress_FLOAT(ADDRESS addr, FLOAT value) {
+
+	pwrite64(process_handle, &value, 4, addr);
+	return 0;
+}
+
+int MemoryTool::WriteAddress_DOUBLE(ADDRESS addr, DOUBLE value) {
+
+	pwrite64(process_handle, &value, 4, addr);
+	return 0;
+}
+
+int MemoryTool::WriteAddress_WORD(ADDRESS addr, WORD value) {
+
+	pwrite64(process_handle, &value, 4, addr);
+	return 0;
+}
+
+int MemoryTool::WriteAddress_BYTE(ADDRESS addr, BYTE value) {
+
+	pwrite64(process_handle, &value, 4, addr);
+	return 0;
+}
+
+int MemoryTool::WriteAddress_QWORD(ADDRESS addr, QWORD value) {
+	pwrite64(process_handle, &value, 4, addr);
+	return 0;
+}
+
+int MemoryTool::isapkinstalled(PACKAGENAME* bm) {
+	char LJ[128];
+	sprintf(LJ, "/data/data/%s/", bm);
+	DIR* dir;
+	dir = opendir(LJ);
+	if (dir == NULL) {
+		return 0;
+	}
+	else {
+		return 1;
+	}
+}
+
+int MemoryTool::isapkrunning(PACKAGENAME* bm) {
+	DIR* dir = NULL;
+	struct dirent* ptr = NULL;
+	FILE* fp = NULL;
+	char filepath[50];
+	char filetext[128];
+	dir = opendir("/proc/");
+	if (dir != NULL) {
+		while ((ptr = readdir(dir)) != NULL) {
+			if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0))
+				continue;
+			if (ptr->d_type != DT_DIR)
+				continue;
+			sprintf(filepath, "/proc/%s/cmdline", ptr->d_name);
+			fp = fopen(filepath, "r");
+			if (NULL != fp) {
+				fgets(filetext, sizeof(filetext), fp);
+				if (strcmp(filetext, bm) == 0) {
+					closedir(dir);
+					return 1;
+				}
+				fclose(fp);
+			}
+		}
+	}
+	closedir(dir);
+	return 0;
+}
+
+int MemoryTool::uninstallapk(PACKAGENAME* bm) {
+	char ml[128];
+	sprintf(ml, "pm uninstall %s", bm);
+	system(ml);
+	system("clear");
+	return 0;
+}
+
+int MemoryTool::installapk(char* lj) {
+	char ml[128];
+	sprintf(ml, "pm install %s", lj);
+	system(ml);
+	system("clear");
+	return 0;
+}
+
+int MemoryTool::killprocess(PACKAGENAME* bm) {
+	int pid = getPID(bm);
+	if (pid == 0) {
+		return -1;
+	}
+	char ml[32];
+	sprintf(ml, "kill %d", pid);
+	system(ml);					// 杀掉进程
+	return 0;
+}
+
+char MemoryTool::GetProcessState(PACKAGENAME* bm) {
+	/*
+	D uninterruptible sleep state (usually IO processes); R
+	running, in an interruptible queue; S
+	In dormant state, quiescent state; T
+	Stop or be tracked, suspend execution; W
+	into memory swap (not valid since kernel 2.6); X
+	Dead process; Z zombie process does not exist but cannot be eliminated temporarily; W:
+	Not enough memory pages to allocate WCHAN
+	waiting process resource; <: high priority process N:
+	Low priority process L: has memory page allocated and locked in memory
+	(instant system or subject to A I/O), i.e., some pages are locked into memory s
+	the leader of the process (with child processes under it); l
+	multi-process (using CLONE_THREAD, similar to NPTL pthreads); +
+	Process group in the background; */
+
+	int pid = getPID(bm);
+	if (pid == 0) {
+		return 0;
+	}
+	FILE* fp;
+	char lj[64];
+	char buff[64];
+	char zt;
+	char zt1[16];
+	sprintf(lj, "/proc/%d/status", pid);
+	fp = fopen(lj, "r");
+	if (fp == NULL) {
+		return 0;
+	}
+
+	while (!feof(fp)) {
+		fgets(buff, sizeof(buff), fp);
+		if (strstr(buff, "State")) {
+			sscanf(buff, "State: %c", &zt);
+			// printf("state:%c\n",zt);
+			// sleep(1);
+			// puts("emmmm");
+			break;
+		}
+	}
+	// putchar(zt);
+	// puts(zt2);
+	fclose(fp);
+	// puts("loopopp");
+	return zt;
+}
+
+int MemoryTool::rebootsystem() {
+	return system("su -c 'reboot'");
+}
+
+int MemoryTool::PutDate() {
+	return system("date +%F-%T");
+}
+
+int MemoryTool::GetDate(char* date) {
+	FILE* fp;
+	system("date +%F-%T > log.txt");
+	if ((fp = fopen("log.txt", "r")) == NULL) {
+		return 0;
+	}
+	fscanf(fp, "%s", date);
+	remove("log.txt");
+	return 1;
+}
+
+int MemoryTool::killGG() {
+	// There is a folder named GG-**** in /data/data/[GG modifier package name]/files/
+	// If there is this folder, get the package name mentioned above and kill the GG modifier
+
+	DIR* dir = NULL;
+	DIR* dirGG = NULL;
+	struct dirent* ptr = NULL;
+	struct dirent* ptrGG = NULL;
+	char filepath[256];			// The size is arbitrary, the path that can install the cmdline file can be
+	char filetext[128];
+	dir = opendir("/data/data");
+	// puts("killing GG");
+	int flag = 1;
+	if (dir != NULL) {
+		while (flag && (ptr = readdir(dir)) != NULL) {
+			if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0))
+				continue;
+			if (ptr->d_type != DT_DIR)
+				continue;
+			sprintf(filepath, "/data/data/%s/files", ptr->d_name);
+			dirGG = opendir(filepath);
+			if (dirGG != NULL) {
+				while ((ptrGG = readdir(dirGG)) != NULL) {
+					if ((strcmp(ptrGG->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0))
+						continue;
+					if (ptrGG->d_type != DT_DIR)
+						continue;
+					if (strstr(ptrGG->d_name, "GG")) {
+						int pid;	// pid
+						pid = getPID(ptr->d_name);
+						if (pid == 0)
+							continue;
+						else
+							killprocess(ptr->d_name);
+					}
+				}
+			}
+		}
+	}
+	closedir(dir);
+	closedir(dirGG);
+	return 0;
+}
+
+int MemoryTool::killXs() {
+	DIR* dir = NULL;
+	struct dirent* ptr = NULL;
+	char filepath[256];
+	char filetext[128];
+	dir = opendir("/data/data");
+	FILE* fp = NULL;
+	if (NULL != dir) {
+		while ((ptr = readdir(dir)) != NULL) {
+			if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0))
+				continue;
+			if (ptr->d_type != DT_DIR)
+				continue;
+			// /data/data/%s/lib/libxscript.so
+			sprintf(filepath, "/data/data/%s/lib/libxscript.so", ptr->d_name);
+			fp = fopen(filepath, "r");
+			if (fp == NULL)
+				continue;
+			else {
+				killprocess(ptr->d_name);
+			}
+			// killprocess(ptr->d_name);
+		}
+	}
+	closedir(dir);
+	return 0;
+}
+
+void MemoryTool::FreezeThread() {
+	int pid;
+	pid = getPID(bm);
+	if (pid == 0) {
+		puts("Error -1");
+		return;
+	}
+	DWORD buf_i;
+	FLOAT buf_f;
+	DOUBLE buf_d;
+	WORD buf_w;
+	BYTE buf_b;
+	QWORD buf_q;
+	if (process_handle == -1) {
+		puts("Error -2");
+		return;
+	}
+	PFREEZE pTemp = value_freeze;
+	while (Freeze == 1) {
+		pid = getPID(bm);
+		if (pid == 0) {
+			puts("Game is Not Run");
+			exit(1);
+			break;
+		}
+		for (int i = 0; i < FreezeCount; i++) {
+			switch (pTemp->type) {
+			case TYPE_DWORD:
+				buf_i = atoi(pTemp->value);
+				pwrite64(process_handle, &buf_i, 4, pTemp->addr);
+				break;
+			case TYPE_FLOAT:
+				buf_f = atof(pTemp->value);
+				pwrite64(process_handle, &buf_f, 4, pTemp->addr);
+				break;
+			case TYPE_DOUBLE:
+				buf_d = atof(pTemp->value);
+				pwrite64(process_handle, &buf_d, 4, pTemp->addr);
+				break;
+			case TYPE_WORD:
+				buf_w = atoi(pTemp->value);
+				pwrite64(process_handle, &buf_w, 4, pTemp->addr);
+				break;
+			case TYPE_BYTE:
+				buf_b = atoi(pTemp->value);
+				pwrite64(process_handle, &buf_b, 4, pTemp->addr);
+				break;
+			case TYPE_QWORD:
+				buf_q = atoi(pTemp->value);
+				pwrite64(process_handle, &buf_q, 4, pTemp->addr);
+				break;
+			default:
+				break;
+			}
+			pTemp = pTemp->next;
+			usleep(delay);
+		}
+		pTemp = value_freeze;
+	}
+	return;
+}
+
+PMAPS MemoryTool::GetResults() {
+	if (Res == NULL) {
+		return NULL;
+	}
+	else {
+		return Res;
+	}
+}
+
+int MemoryTool::AddFreezeItem_All(char* Value, TYPE type, OFFSET offset) {
+	if (ResCount == 0) {
+		return -1;
+	}
+	PMAPS pTemp = Res;
+	for (int i = 0; i < ResCount; i++) {
+		switch (type) {
+		case TYPE_DWORD:
+			AddFreezeItem(pTemp->addr, Value, TYPE_DWORD, offset);
+			break;
+		case TYPE_FLOAT:
+			AddFreezeItem(pTemp->addr, Value, TYPE_FLOAT, offset);
+			break;
+		case TYPE_DOUBLE:
+			AddFreezeItem(pTemp->addr, Value, TYPE_DOUBLE, offset);
+			break;
+		case TYPE_WORD:
+			AddFreezeItem(pTemp->addr, Value, TYPE_WORD, offset);
+			break;
+		case TYPE_BYTE:
+			AddFreezeItem(pTemp->addr, Value, TYPE_BYTE, offset);
+			break;
+		case TYPE_QWORD:
+			AddFreezeItem(pTemp->addr, Value, TYPE_QWORD, offset);
+			break;
+		default:
+			SetTextColor(COLOR_SKY_BLUE);
+			puts("You Choose a NULL type");
+			break;
+		}
+		pTemp = pTemp->next;
+	}
+	return 0;
+}
+
+int MemoryTool::AddFreezeItem(ADDRESS addr, char* value, TYPE type, OFFSET offset) {
+	switch (type) {
+	case TYPE_DWORD:
+		AddFreezeItem_DWORD(addr + offset, value);
+		break;
+	case TYPE_FLOAT:
+		AddFreezeItem_FLOAT(addr + offset, value);
+		break;
+	case TYPE_DOUBLE:
+		AddFreezeItem_DOUBLE(addr + offset, value);
+		break;
+	case TYPE_WORD:
+		AddFreezeItem_WORD(addr + offset, value);
+		break;
+	case TYPE_BYTE:
+		AddFreezeItem_BYTE(addr + offset, value);
+		break;
+	case TYPE_QWORD:
+		AddFreezeItem_QWORD(addr + offset, value);
+		break;
+	default:
+		SetTextColor(COLOR_SKY_BLUE);
+		puts("You Choose a NULL type");
+		break;
+	}
+	return 0;
+}
+
+int MemoryTool::AddFreezeItem_DWORD(ADDRESS addr, char* value) {
+	if (FreezeCount == 0) {
+		value_freeze = pEnd = pNew = (PFREEZE)malloc(FRE);
+		pNew->next = NULL;
+		pEnd = pNew;
+		value_freeze = pNew;
+		pNew->addr = addr;
+		pNew->type = TYPE_DWORD;
+		pNew->value = value;
+		FreezeCount += 1;
+	}
+	else {
+		pNew = (PFREEZE)malloc(FRE);
+		pNew->next = NULL;
+		pEnd->next = pNew;
+		pEnd = pNew;
+		pNew->addr = addr;
+		pNew->type = TYPE_DWORD;
+		pNew->value = value;
+		FreezeCount += 1;
+	}
+	return 0;
+}
+
+int MemoryTool::AddFreezeItem_FLOAT(ADDRESS addr, char* value) {
+	if (FreezeCount == 0) {
+		value_freeze = pEnd = pNew = (PFREEZE)malloc(FRE);
+		pNew->next = NULL;
+		pEnd = pNew;
+		value_freeze = pNew;
+		pNew->addr = addr;
+		pNew->type = TYPE_FLOAT;
+		pNew->value = value;
+		FreezeCount += 1;
+	}
+	else {
+		pNew = (PFREEZE)malloc(FRE);
+		pNew->next = NULL;
+		pEnd->next = pNew;
+		pEnd = pNew;
+		pNew->addr = addr;
+		pNew->type = TYPE_FLOAT;
+		pNew->value = value;
+		FreezeCount += 1;
+	}
+	return 0;
+}
+
+int MemoryTool::AddFreezeItem_DOUBLE(ADDRESS addr, char* value) {
+	if (FreezeCount == 0) {
+		value_freeze = pEnd = pNew = (PFREEZE)malloc(FRE);
+		pNew->next = NULL;
+		pEnd = pNew;
+		value_freeze = pNew;
+		pNew->addr = addr;
+		pNew->type = TYPE_DOUBLE;
+		pNew->value = value;
+		FreezeCount += 1;
+	}
+	else {
+		pNew = (PFREEZE)malloc(FRE);
+		pNew->next = NULL;
+		pEnd->next = pNew;
+		pEnd = pNew;
+		pNew->addr = addr;
+		pNew->type = TYPE_DOUBLE;
+		pNew->value = value;
+		FreezeCount += 1;
+	}
+	return 0;
+}
+
+int MemoryTool::AddFreezeItem_WORD(ADDRESS addr, char* value) {
+	if (FreezeCount == 0) {
+		value_freeze = pEnd = pNew = (PFREEZE)malloc(FRE);
+		pNew->next = NULL;
+		pEnd = pNew;
+		value_freeze = pNew;
+		pNew->addr = addr;
+		pNew->type = TYPE_WORD;
+		pNew->value = value;
+		FreezeCount += 1;
+	}
+	else {
+		pNew = (PFREEZE)malloc(FRE);
+		pNew->next = NULL;
+		pEnd->next = pNew;
+		pEnd = pNew;
+		pNew->addr = addr;
+		pNew->type = TYPE_WORD;
+		pNew->value = value;
+		FreezeCount += 1;
+	}
+	return 0;
+}
+
+int MemoryTool::AddFreezeItem_BYTE(ADDRESS addr, char* value) {
+	if (FreezeCount == 0) {
+		value_freeze = pEnd = pNew = (PFREEZE)malloc(FRE);
+		pNew->next = NULL;
+		pEnd = pNew;
+		value_freeze = pNew;
+		pNew->addr = addr;
+		pNew->type = TYPE_BYTE;
+		pNew->value = value;
+		FreezeCount += 1;
+	}
+	else {
+		pNew = (PFREEZE)malloc(FRE);
+		pNew->next = NULL;
+		pEnd->next = pNew;
+		pEnd = pNew;
+		pNew->addr = addr;
+		pNew->type = TYPE_BYTE;
+		pNew->value = value;
+		FreezeCount += 1;
+	}
+	return 0;
+}
+
+int MemoryTool::AddFreezeItem_QWORD(ADDRESS addr, char* value) {
+	if (FreezeCount == 0) {
+		value_freeze = pEnd = pNew = (PFREEZE)malloc(FRE);
+		pNew->next = NULL;
+		pEnd = pNew;
+		value_freeze = pNew;
+		pNew->addr = addr;
+		pNew->type = TYPE_QWORD;
+		pNew->value = value;
+		FreezeCount += 1;
+	}
+	else {
+		pNew = (PFREEZE)malloc(FRE);
+		pNew->next = NULL;
+		pEnd->next = pNew;
+		pEnd = pNew;
+		pNew->addr = addr;
+		pNew->type = TYPE_QWORD;
+		pNew->value = value;
+		FreezeCount += 1;
+	}
+	return 0;
+}
+
+int MemoryTool::RemoveFreezeItem(ADDRESS addr) {
+	PFREEZE pTemp = value_freeze;
+	PFREEZE p1 = NULL;
+	PFREEZE p2 = NULL;
+	for (int i = 0; i < FreezeCount; i++) {
+		p1 = pTemp;
+		p2 = pTemp->next;
+		if (pTemp->addr == addr) {
+			p1->next = p2;
+			free(pTemp);
+			FreezeCount -= 1;
+			// printf("Freeze count:%d\n",FreezeCount);
+			// break;//Prevent the address from freezing repeatedly, so it is not added, of course, it can also be added
+		}
+		pTemp = p2;
+	}
+	return 0;
+}
+
+int MemoryTool::RemoveFreezeItem_All() {
+	PFREEZE pHead = value_freeze;
+	PFREEZE pTemp = pHead;
+	int i;
+	for (i = 0; i < FreezeCount; i++) {
+		pTemp = pHead;
+		pHead = pHead->next;
+		free(pTemp);
+		FreezeCount -= 1;
+	}
+	free(value_freeze);
+	FreezeCount -= 1;
+	return 0;
+}
+
+int MemoryTool::StartFreeze() {
+	if (Freeze == 1) {
+		return -1;
+	}
+	//int a;
+	//strcpy(Fbm, bm);	
+	Freeze = 1;
+	//pthread_create(&pth, NULL, FreezeThread, NULL);
+	thread th1(&MemoryTool::FreezeThread, this);
+	//th1.join();
+	return 0;
+}
+
+int MemoryTool::StopFreeze() {
+	Freeze = 0;
+	return 0;
+}
+
+int MemoryTool::SetFreezeDelay(long int De) {
+	delay = De;
+	return 0;
+}
+
+int MemoryTool::PrintFreezeItems() {
+	PFREEZE pTemp = value_freeze;
+	for (int i = 0; i < FreezeCount; i++) {
+		const char* type = (char*)malloc(sizeof(char));
+		switch (pTemp->type) {
+		case TYPE_DWORD:
+			type = "DWORD";
+			break;
+		case TYPE_FLOAT:
+			type = "FLOAT";
+			break;
+		case TYPE_DOUBLE:
+			type = "DOUBLE";
+			break;
+		case TYPE_WORD:
+			type = "WORD";
+			break;
+		case TYPE_BYTE:
+			type = "BYTE";
+			break;
+		case TYPE_QWORD:
+			type = "QWORD";
+			break;
+		default:
+			type = "";
+			break;
+		}
+		printf("FreezeAddr:0x%lX  Type:%s  Value:%s\n", pTemp->addr, type, pTemp->value);
+		pTemp = pTemp->next;
+	}
+	return 0;
+}
+
+
+int MemoryTool::SetSearchRange(TYPE type) {
+	switch (type) {
+	case ALL:
+		MemorySearchRange = 0;
+		break;
+	case B_BAD:
+		MemorySearchRange = 1;
+		break;
+	case C_ALLOC:
+		MemorySearchRange = 2;
+		break;
+	case C_BSS:
+		MemorySearchRange = 3;
+		break;
+	case C_DATA:
+		MemorySearchRange = 4;
+		break;
+	case C_HEAP:
+		MemorySearchRange = 5;
+		break;
+	case JAVA_HEAP:
+		MemorySearchRange = 6;
+		break;
+	case A_ANONMYOUS:
+		MemorySearchRange = 7;
+		break;
+	case CODE_SYSTEM:
+		MemorySearchRange = 8;
+		break;
+	case STACK:
+		MemorySearchRange = 9;
+		break;
+	case ASHMEM:
+		MemorySearchRange = 10;
+		break;
+	default:
+		printf("\033[32;1mYou Select A NULL Type!\n");
+		break;
+	}
+	return 0;
+}
+
+PMAPS MemoryTool::readmaps(TYPE type) {
+	PMAPS pMap = NULL;
+	switch (type) {
+	case ALL:
+		pMap = readmaps_all();
+		break;
+	case B_BAD:
+		pMap = readmaps_bad();
+		break;
+	case C_ALLOC:
+		pMap = readmaps_c_alloc();
+		break;
+	case C_BSS:
+		pMap = readmaps_c_bss();
+		break;
+	case C_DATA:
+		pMap = readmaps_c_data();
+		break;
+	case C_HEAP:
+		pMap = readmaps_c_heap();
+		break;
+	case JAVA_HEAP:
+		pMap = readmaps_java_heap();
+		break;
+	case A_ANONMYOUS:
+		pMap = readmaps_a_anonmyous();
+		break;
+	case CODE_SYSTEM:
+		pMap = readmaps_code_system();
+		break;
+	case STACK:
+		pMap = readmaps_stack();
+		break;
+	case ASHMEM:
+		pMap = readmaps_ashmem();
+		break;
+	default:
+		printf("\033[32;1mYou Select A NULL Type!\n");
+		break;
+	}
+	if (pMap == NULL) {
+		return 0;
+	}
+	return pMap;
+}
+
+PMAPS MemoryTool::readmaps_all() {
+	PMAPS pHead = NULL;
+	PMAPS pNew;
+	PMAPS pEnd;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	FILE* fp;
+	int i = 0, flag = 1;
+	char lj[64], buff[256];
+	int pid = getPID(bm);
+	sprintf(lj, "/proc/%d/maps", pid);
+	fp = fopen(lj, "r");
+	if (fp == NULL) {
+		puts("Memory read failed!");
+		return NULL;
+	}
+	while (!feof(fp)) {
+		fgets(buff, sizeof(buff), fp);
+		if (strstr(buff, "rw") != NULL && !feof(fp)) {
+			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
+			flag = 1;
+		}
+		else {
+			flag = 0;
+		}
+		if (flag == 1) {
+			i++;
+			if (i == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				pHead = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+		}
+	}
+	free(pNew);
+	fclose(fp);
+	return pHead;
+}
+
+PMAPS MemoryTool::readmaps_bad() {
+	PMAPS pHead = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pEnd = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	FILE* fp;
+	int i = 0, flag = 1;
+	char lj[64], buff[256];
+	int pid = getPID(bm);
+	sprintf(lj, "/proc/%d/maps", pid);
+	fp = fopen(lj, "r");
+	if (fp == NULL) {
+		puts("Memory read failed!");
+		return NULL;
+	}
+	while (!feof(fp)) {
+		fgets(buff, sizeof(buff), fp);
+		if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff, "kgsl-3d0")) {
+			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
+			flag = 1;
+		}
+		else {
+			flag = 0;
+		}
+		if (flag == 1) {
+			i++;
+			if (i == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				pHead = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+		}
+	}
+	free(pNew);
+	fclose(fp);
+	return pHead;
+}
+
+PMAPS MemoryTool::readmaps_c_alloc() {
+	PMAPS pHead = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pEnd = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	FILE* fp;
+	int i = 0, flag = 1;
+	char lj[64], buff[256];
+	int pid = getPID(bm);
+	sprintf(lj, "/proc/%d/maps", pid);
+	fp = fopen(lj, "r");
+	if (fp == NULL) {
+		puts("Memory read failed!");
+		return NULL;
+	}
+	while (!feof(fp)) {
+		fgets(buff, sizeof(buff), fp);
+		if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff, "[anon:libc_malloc]")) {
+			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
+			flag = 1;
+		}
+		else {
+			flag = 0;
+		}
+		if (flag == 1) {
+			i++;
+			if (i == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				pHead = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+		}
+	}
+	free(pNew);
+	fclose(fp);
+	return pHead;
+}
+
+PMAPS MemoryTool::readmaps_c_bss() {
+	PMAPS pHead = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pEnd = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	FILE* fp;
+	int i = 0, flag = 1;
+	char lj[64], buff[256];
+	int pid = getPID(bm);
+	sprintf(lj, "/proc/%d/maps", pid);
+	fp = fopen(lj, "r");
+	if (fp == NULL) {
+		puts("Memory read failed!");
+		return NULL;
+	}
+	while (!feof(fp)) {
+		fgets(buff, sizeof(buff), fp);
+		if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff, "[anon:.bss]")) {
+			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
+			flag = 1;
+		}
+		else {
+			flag = 0;
+		}
+		if (flag == 1) {
+			i++;
+			if (i == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				pHead = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+		}
+	}
+	free(pNew);
+	fclose(fp);
+	return pHead;
+}
+
+PMAPS MemoryTool::readmaps_c_data() {
+	PMAPS pHead = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pEnd = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	FILE* fp;
+	int i = 0, flag = 1;
+	char lj[64], buff[256];
+	int pid = getPID(bm);
+	sprintf(lj, "/proc/%d/maps", pid);
+	fp = fopen(lj, "r");
+	if (fp == NULL) {
+		puts("Memory read failed!");
+		return NULL;
+	}
+	while (!feof(fp)) {
+		fgets(buff, sizeof(buff), fp);
+		if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff, "/data/app/")) {
+			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
+			flag = 1;
+		}
+		else {
+			flag = 0;
+		}
+		if (flag == 1) {
+			i++;
+			if (i == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				pHead = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+		}
+	}
+	free(pNew);
+	fclose(fp);
+	return pHead;
+}
+
+PMAPS MemoryTool::readmaps_c_heap() {
+	PMAPS pHead = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pEnd = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	FILE* fp;
+	int i = 0, flag = 1;
+	char lj[64], buff[256];
+	int pid = getPID(bm);
+	sprintf(lj, "/proc/%d/maps", pid);
+	fp = fopen(lj, "r");
+	if (fp == NULL) {
+		puts("Memory read failed!");
+		return NULL;
+	}
+	while (!feof(fp)) {
+		fgets(buff, sizeof(buff), fp);
+		if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff, "[heap]")) {
+			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
+			flag = 1;
+		}
+		else {
+			flag = 0;
+		}
+		if (flag == 1) {
+			i++;
+			if (i == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				pHead = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+		}
+	}
+	free(pNew);
+	fclose(fp);
+	return pHead;
+}
+
+PMAPS MemoryTool::readmaps_java_heap() {
+	PMAPS pHead = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pEnd = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	FILE* fp;
+	int i = 0, flag = 1;
+	char lj[64], buff[256];
+	int pid = getPID(bm);
+	sprintf(lj, "/proc/%d/maps", pid);
+	fp = fopen(lj, "r");
+	if (fp == NULL) {
+		puts("Memory read failed!");
+		return NULL;
+	}
+	while (!feof(fp)) {
+		fgets(buff, sizeof(buff), fp);
+		if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff, "/dev/ashmem/")) {
+			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
+			flag = 1;
+		}
+		else {
+			flag = 0;
+		}
+		if (flag == 1) {
+			i++;
+			if (i == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				pHead = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+		}
+	}
+	free(pNew);
+	fclose(fp);
+	return pHead;
+}
+
+PMAPS MemoryTool::readmaps_a_anonmyous() {
+	PMAPS pHead = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pEnd = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	FILE* fp;
+	int i = 0, flag = 1;
+	char lj[64], buff[256];
+	int pid = getPID(bm);
+	sprintf(lj, "/proc/%d/maps", pid);
+	fp = fopen(lj, "r");
+	if (fp == NULL) {
+		puts("Memory read failed!");
+		return NULL;
+	}
+	while (!feof(fp)) {
+		fgets(buff, sizeof(buff), fp);
+		if (strstr(buff, "rw") != NULL && !feof(fp) && (strlen(buff) < 42)) {
+			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
+			flag = 1;
+		}
+		else {
+			flag = 0;
+		}
+		if (flag == 1) {
+			i++;
+			if (i == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				pHead = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+		}
+	}
+	free(pNew);
+	fclose(fp);
+	return pHead;
+}
+
+PMAPS MemoryTool::readmaps_code_system() {
+	PMAPS pHead = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pEnd = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	FILE* fp;
+	int i = 0, flag = 1;
+	char lj[64], buff[256];
+	int pid = getPID(bm);
+	sprintf(lj, "/proc/%d/maps", pid);
+	fp = fopen(lj, "r");
+	if (fp == NULL) {
+		puts("Memory read failed!");
+		return NULL;
+	}
+	while (!feof(fp)) {
+		fgets(buff, sizeof(buff), fp);
+		if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff, "/system")) {
+			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
+			flag = 1;
+		}
+		else {
+			flag = 0;
+		}
+		if (flag == 1) {
+			i++;
+			if (i == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				pHead = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+		}
+	}
+	free(pNew);
+	fclose(fp);
+	return pHead;
+}
+
+PMAPS MemoryTool::readmaps_stack() {
+	PMAPS pHead = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pEnd = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	FILE* fp;
+	int i = 0, flag = 1;
+	char lj[64], buff[256];
+	int pid = getPID(bm);
+	sprintf(lj, "/proc/%d/maps", pid);
+	fp = fopen(lj, "r");
+	if (fp == NULL) {
+		puts("Memory read failed!");
+		return NULL;
+	}
+	while (!feof(fp)) {
+		fgets(buff, sizeof(buff), fp);
+		if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff, "[stack]")) {
+			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
+			flag = 1;
+		}
+		else {
+			flag = 0;
+		}
+		if (flag == 1) {
+			i++;
+			if (i == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				pHead = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+		}
+	}
+	free(pNew);
+	fclose(fp);
+	return pHead;
+}
+
+PMAPS MemoryTool::readmaps_ashmem() {
+	PMAPS pHead = NULL;
+	PMAPS pNew = NULL;
+	PMAPS pEnd = NULL;
+	pEnd = pNew = (PMAPS)malloc(LEN);
+	FILE* fp;
+	int i = 0, flag = 1;
+	char lj[64], buff[256];
+	int pid = getPID(bm);
+	sprintf(lj, "/proc/%d/maps", pid);
+	fp = fopen(lj, "r");
+	if (fp == NULL) {
+		puts("Memory read failed!");
+		return NULL;
+	}
+	while (!feof(fp)) {
+		fgets(buff, sizeof(buff), fp);
+		if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff, "/dev/ashmem/")
+			&& !strstr(buff, "dalvik")) {
+			sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
+			flag = 1;
+		}
+		else {
+			flag = 0;
+		}
+		if (flag == 1) {
+			i++;
+			if (i == 1) {
+				pNew->next = NULL;
+				pEnd = pNew;
+				pHead = pNew;
+			}
+			else {
+				pNew->next = NULL;
+				pEnd->next = pNew;
+				pEnd = pNew;
+			}
+			pNew = (PMAPS)malloc(LEN);
+		}
+	}
+	free(pNew);
+	fclose(fp);
+	return pHead;
+}
+
diff --git a/MemoryTool.h b/MemoryTool.h
index c033679..e3baf20 100644
--- a/MemoryTool.h
+++ b/MemoryTool.h
@@ -1,232 +1,231 @@
-#pragma
-#include<cstddef>
-#include<cstdint>
-#include<pthread.h>
-
-struct MAPS {
-    long int addr;
-    long int taddr;
-    int type;
-    struct MAPS *next;
-};
-
-struct RESULT {
-    long int addr;
-    struct RESULT *next;
- };
-
-struct FREEZE {
-    long int addr; // address
-    char *value; // value
-    int type; // type
-    struct FREEZE *next; // pointer to the next node
-};
-
-typedef int BOOLEAN;
-typedef struct MAPS *PMAPS; //A linked list that stores maps
-typedef struct RESULT *PRES; // linked list to store results
-typedef struct FREEZE *PFREEZE; // Linked list to store frozen data
-
-typedef int TYPE;
-typedef int RANGE;
-typedef int COUNT;
-typedef int COLOR;
-typedef long int OFFSET;
-typedef long int ADDRESS;
-typedef char PACKAGENAME;
-
-typedef int64_t QWORD;
-typedef int32_t DWORD;
-typedef int16_t WORD;
-typedef int8_t BYTE;
-typedef float FLOAT;
-typedef double DOUBLE;
-
-enum type {
-     TYPE_DWORD,
-     TYPE_FLOAT,
-     TYPE_DOUBLE,
-     TYPE_WORD,
-     TYPE_BYTE,
-     TYPE_QWORD,
-};
-
-enum Range {
-     ALL, // all memory
-     B_BAD, // B memory
-     C_ALLOC, // Ca memory
-     C_BSS, // Cb memory
-     C_DATA, // Cd memory
-     C_HEAP, // Ch memory
-     JAVA_HEAP, // Jh memory
-     A_ANONMYOUS, // A memory
-     CODE_SYSTEM, // Xs memory
-     STACK, // S memory
-     ASHMEM // As memory
-};
-
-enum Color {
-     COLOR_SILVERY, // silver
-     COLOR_RED, // Red
-     COLOR_GREEN, // Green
-     COLOR_YELLOW, // Yellow
-     COLOR_DARK_BLUE, // Blue
-     COLOR_PINK, // Pink
-     COLOR_SKY_BLUE, // Sky Blue
-     COLOR_WHITE // White
-};
-
-#define MODE_ROOT "MODE_ROOT"
-#define MODE_NO_ROOT "MODE_NO_ROOT"
-#define TRUE 1
-#define FALSE 0
-#define LEN sizeof(struct MAPS)
-#define FRE sizeof(struct FREEZE)
-
-
-class MemoryTool
-{
-public:
-    PMAPS Res = NULL; // Global buff (where data is saved)
-    PFREEZE value_freeze = NULL; // For storing frozen data
-    PFREEZE pEnd = NULL;
-    PFREEZE pNew = NULL;
-    int FreezeCount = 0; // Number of frozen data
-    int Freeze = 0; // switch
-    pthread_t pth;
-    char bm[64]; // Package names
-    long int delay = 30000; // Freeze delay, default 30000us
-    int process_handle; //mem process_handle
-    int ResCount = 0; // number of results
-    int gs = 0;
-    int MemorySearchRange = 0; // 0 for all
-    int ms = 0;
-
-    int SetTextColor(int);
-    int getPID(char [64]); // get pid
-	void initXMemoryTools(char *, char *);
-    int SetSearchRange(int); // Set search scope
-    PMAPS readmaps(int);
-    PMAPS readmaps_all(); // read maps file
-    PMAPS readmaps_bad(); // read maps file
-    PMAPS readmaps_c_alloc(); // read maps file
-    PMAPS readmaps_c_bss(); // read maps file
-    PMAPS readmaps_c_data(); // read maps file
-    PMAPS readmaps_c_heap(); // read maps file
-    PMAPS readmaps_java_heap(); // read maps file
-    PMAPS readmaps_a_anonmyous(); // read maps file
-    PMAPS readmaps_code_system(); // read maps file
-    PMAPS readmaps_stack(); // read maps file
-    PMAPS readmaps_ashmem(); // read maps file
-
-    void BaseAddressSearch(char*, int , long int); // base search
-    PMAPS BaseAddressSearch_DWORD(DWORD, long int, PMAPS); // DWORD
-    PMAPS BaseAddressSearch_FLOAT(FLOAT , long int, PMAPS ); // FLOAT
-    PMAPS BaseAddressSearch_DOUBLE(DOUBLE , long int , PMAPS); // DOUBLE
-    PMAPS BaseAddressSearch_WORD(WORD, long int, PMAPS); // WORD
-    PMAPS BaseAddressSearch_BYTE(BYTE, long int, PMAPS); // BYTE
-    PMAPS BaseAddressSearch_QWORD(QWORD, long int, PMAPS); // QWORD
-
-
-    void RangeMemorySearch(char*, char *, int); // range search
-    PMAPS RangeMemorySearch_DWORD(DWORD, DWORD, PMAPS); // DWORD
-    PMAPS RangeMemorySearch_FLOAT(FLOAT, FLOAT, PMAPS); // FLOAT
-    PMAPS RangeMemorySearch_DOUBLE(DOUBLE, DOUBLE, PMAPS); // WORD
-    PMAPS RangeMemorySearch_WORD(WORD, WORD, PMAPS); // WORD
-    PMAPS RangeMemorySearch_BYTE(BYTE, BYTE, PMAPS); // BYTE
-    PMAPS RangeMemorySearch_QWORD(QWORD, QWORD, PMAPS); // QWORD
-
-    void MemorySearch(char*, int); // Type search, where value needs to pass in an address
-    PMAPS MemorySearch_DWORD(DWORD, PMAPS); // Memory Search DWORD
-    PMAPS MemorySearch_FLOAT(FLOAT, PMAPS); // Memory search FLOAT
-    PMAPS MemorySearch_DOUBLE(DOUBLE, PMAPS); // Memory Search DOUBLE
-    PMAPS MemorySearch_WORD(WORD, PMAPS); // Memory Search WORD
-    PMAPS MemorySearch_BYTE(BYTE, PMAPS); // Memory Search BYTE
-    PMAPS MemorySearch_QWORD(QWORD, PMAPS); // Memory Search QWORD
-
-    void MemoryOffset(char *, long int, int ); // search offset
-    PMAPS MemoryOffset_DWORD(DWORD , long int, PMAPS); // search offset DWORD
-    PMAPS MemoryOffset_FLOAT(FLOAT , long int, PMAPS); // search offset FLOAT
-    PMAPS MemoryOffset_DOUBLE(DOUBLE , long int , PMAPS); // search offset DOUBLE
-    PMAPS MemoryOffset_WORD(WORD , long int , PMAPS); // search offset WORD
-    PMAPS MemoryOffset_BYTE(BYTE , long int , PMAPS); // search offset BYTE
-    PMAPS MemoryOffset_QWORD(QWORD , long int, PMAPS); // search offset QWORD
-
-    void RangeMemoryOffset(char *, char *, long int, int); // range offset
-    PMAPS RangeMemoryOffset_DWORD(DWORD, DWORD , long int, PMAPS); // range offset DWORD
-    PMAPS RangeMemoryOffset_FLOAT(FLOAT , FLOAT, long int , PMAPS); // range offset FLOAT
-    PMAPS RangeMemoryOffset_DOUBLE(DOUBLE, DOUBLE, long int, PMAPS); // range offset DOUBLE
-    PMAPS RangeMemoryOffset_WORD(WORD, WORD, long int, PMAPS); // range offset WORD
-    PMAPS RangeMemoryOffset_BYTE(BYTE, BYTE, long int, PMAPS); // range offset BYTE
-    PMAPS RangeMemoryOffset_QWORD(QWORD, QWORD, long int, PMAPS); // range offset QWORD
-
-    void MemoryWrite(char *, long int, int); // memory write
-    int MemoryWrite_DWORD(DWORD, PMAPS, long int); // memory write DWORD
-    int MemoryWrite_FLOAT(FLOAT, PMAPS, long int); // memory write FLOAT
-    int MemoryWrite_DOUBLE(DOUBLE, PMAPS, long int); // memory write DOUBLE
-    int MemoryWrite_WORD(WORD, PMAPS, long int); // memory write WORD
-    int MemoryWrite_BYTE(BYTE, PMAPS, long int); // memory write BYTE
-    int MemoryWrite_QWORD(QWORD, PMAPS, long int); // memory write QWORD
-
-
-    int WriteAddress(long int, char *, int); // Modify the value in the address
-    int WriteAddress_DWORD(ADDRESS, DWORD);
-    int WriteAddress_FLOAT(ADDRESS, FLOAT);
-    int WriteAddress_DOUBLE(ADDRESS, DOUBLE);
-    int WriteAddress_WORD(ADDRESS, WORD);
-    int WriteAddress_BYTE(ADDRESS, BYTE);
-    int WriteAddress_QWORD(ADDRESS, QWORD);
-
-    void PrintResults(); // Print the contents of Res
-    void ClearResults(); // Clear the linked list and free up space
-    void ClearMaps(PMAPS); // Clear maps
-    int GetResultCount(); //Get the number of search results
-
-    int isapkinstalled(char *); // Check if the app is installed
-    int isapkrunning(char *); // Check if the app is running
-    int killprocess(char *); // kill the process
-    char GetProcessState(char *); // Get process state
-    int killGG(); // kill the gg modifier
-    int killXs(); // kill xs
-    int uninstallapk(char *); // silently remove software
-    int installapk(char *); // silently uninstall the software
-    int rebootsystem(); // reboot the system (phone)
-    int PutDate(); // output system date
-    int GetDate(char *); // Get system time
-
-    PMAPS GetResults(); // Get the result, return the head pointer
-    int AddFreezeItem_All(char *, int , long int); // Freeze all results
-    int AddFreezeItem(long int , char *, int , long int); // add frozen data
-    int AddFreezeItem_DWORD(long int , char *); // DWORD
-    int AddFreezeItem_FLOAT(long int, char *); // FLOAT
-    int AddFreezeItem_DOUBLE(long int, char *); // DOUBLE
-    int AddFreezeItem_WORD(long int, char *); // WORD
-    int AddFreezeItem_BYTE(long int, char *); // BYTE
-    int AddFreezeItem_QWORD(long int, char *); // QWORD
-
-    int RemoveFreezeItem(long int); // clear fixed freeze data
-    int RemoveFreezeItem_All(); // clear all frozen data
-    int StartFreeze(); // start freezing
-    int StopFreeze(); // stop freezing
-    int SetFreezeDelay(long int); // set the freeze delay
-    int PrintFreezeItems(); // print the freeze list
-
-    char *GetAddressValue(ADDRESS,int);
-    DWORD GetAddressValue_DWORD(ADDRESS);
-    FLOAT GetAddressValue_FLOAT(ADDRESS);
-    DOUBLE GetAddressValue_DOUBLE(ADDRESS);
-    WORD GetAddressValue_WORD(ADDRESS);
-    BYTE GetAddressValue_BYTE(ADDRESS);
-    QWORD GetAddressValue_QWORD(ADDRESS);
-
-    char *getRightText(char *,char *,int);//Get the right text
-    bool getMask(long int ,char *);//Judgment mask
-    void MaskSearch(char *, int );//Mask search
-
-    bool snowpd(long int);
-    long int GetModuleBase(char *,char * ,int);
-    void FreezeThread();
-};
-
-
- 
\ No newline at end of file
+#pragma
+#include<cstddef>
+#include<cstdint>
+#include<pthread.h>
+
+struct MAPS {
+    long int addr;
+    long int taddr;
+    int type;
+    struct MAPS* next;
+};
+
+struct RESULT {
+    long int addr;
+    struct RESULT* next;
+};
+
+struct FREEZE {
+    long int addr; // address
+    char* value; // value
+    int type; // type
+    struct FREEZE* next; // pointer to the next node
+};
+
+typedef int BOOLEAN;
+typedef struct MAPS* PMAPS; //A linked list that stores maps
+typedef struct RESULT* PRES; // linked list to store results
+typedef struct FREEZE* PFREEZE; // Linked list to store frozen data
+
+typedef int TYPE;
+typedef int RANGE;
+typedef int COUNT;
+typedef int COLOR;
+typedef long int OFFSET;
+typedef long int ADDRESS;
+typedef char PACKAGENAME;
+
+typedef int64_t QWORD;
+typedef int32_t DWORD;
+typedef int16_t WORD;
+typedef int8_t BYTE;
+typedef float FLOAT;
+typedef double DOUBLE;
+
+enum type {
+    TYPE_DWORD,
+    TYPE_FLOAT,
+    TYPE_DOUBLE,
+    TYPE_WORD,
+    TYPE_BYTE,
+    TYPE_QWORD,
+};
+
+enum Range {
+    ALL, // all memory
+    B_BAD, // B memory
+    C_ALLOC, // Ca memory
+    C_BSS, // Cb memory
+    C_DATA, // Cd memory
+    C_HEAP, // Ch memory
+    JAVA_HEAP, // Jh memory
+    A_ANONMYOUS, // A memory
+    CODE_SYSTEM, // Xs memory
+    STACK, // S memory
+    ASHMEM // As memory
+};
+
+enum Color {
+    COLOR_SILVERY, // silver
+    COLOR_RED, // Red
+    COLOR_GREEN, // Green
+    COLOR_YELLOW, // Yellow
+    COLOR_DARK_BLUE, // Blue
+    COLOR_PINK, // Pink
+    COLOR_SKY_BLUE, // Sky Blue
+    COLOR_WHITE // White
+};
+
+#define MODE_ROOT "MODE_ROOT"
+#define MODE_NO_ROOT "MODE_NO_ROOT"
+#define TRUE 1
+#define FALSE 0
+#define LEN sizeof(struct MAPS)
+#define FRE sizeof(struct FREEZE)
+
+
+class MemoryTool
+{
+public:
+    PMAPS Res = NULL; // Global buff (where data is saved)
+    PFREEZE value_freeze = NULL; // For storing frozen data
+    PFREEZE pEnd = NULL;
+    PFREEZE pNew = NULL;
+    int FreezeCount = 0; // Number of frozen data
+    int Freeze = 0; // switch
+    pthread_t pth;
+    char bm[64]; // Package names
+    long int delay = 30000; // Freeze delay, default 30000us
+    int process_handle; //mem process_handle
+    int ResCount = 0; // number of results
+    int gs = 0;
+    int MemorySearchRange = 0; // 0 for all
+    int ms = 0;
+
+    int SetTextColor(int);
+    int getPID(char[64]); // get pid
+    void initXMemoryTools(char*, char*);
+    int SetSearchRange(int); // Set search scope
+    PMAPS readmaps(int);
+    PMAPS readmaps_all(); // read maps file
+    PMAPS readmaps_bad(); // read maps file
+    PMAPS readmaps_c_alloc(); // read maps file
+    PMAPS readmaps_c_bss(); // read maps file
+    PMAPS readmaps_c_data(); // read maps file
+    PMAPS readmaps_c_heap(); // read maps file
+    PMAPS readmaps_java_heap(); // read maps file
+    PMAPS readmaps_a_anonmyous(); // read maps file
+    PMAPS readmaps_code_system(); // read maps file
+    PMAPS readmaps_stack(); // read maps file
+    PMAPS readmaps_ashmem(); // read maps file
+
+    void BaseAddressSearch(char*, int, long int); // base search
+    PMAPS BaseAddressSearch_DWORD(DWORD, long int, PMAPS); // DWORD
+    PMAPS BaseAddressSearch_FLOAT(FLOAT, long int, PMAPS); // FLOAT
+    PMAPS BaseAddressSearch_DOUBLE(DOUBLE, long int, PMAPS); // DOUBLE
+    PMAPS BaseAddressSearch_WORD(WORD, long int, PMAPS); // WORD
+    PMAPS BaseAddressSearch_BYTE(BYTE, long int, PMAPS); // BYTE
+    PMAPS BaseAddressSearch_QWORD(QWORD, long int, PMAPS); // QWORD
+
+
+    void RangeMemorySearch(char*, char*, int); // range search
+    PMAPS RangeMemorySearch_DWORD(DWORD, DWORD, PMAPS); // DWORD
+    PMAPS RangeMemorySearch_FLOAT(FLOAT, FLOAT, PMAPS); // FLOAT
+    PMAPS RangeMemorySearch_DOUBLE(DOUBLE, DOUBLE, PMAPS); // WORD
+    PMAPS RangeMemorySearch_WORD(WORD, WORD, PMAPS); // WORD
+    PMAPS RangeMemorySearch_BYTE(BYTE, BYTE, PMAPS); // BYTE
+    PMAPS RangeMemorySearch_QWORD(QWORD, QWORD, PMAPS); // QWORD
+
+    void MemorySearch(char*, int); // Type search, where value needs to pass in an address
+    PMAPS MemorySearch_DWORD(DWORD, PMAPS); // Memory Search DWORD
+    PMAPS MemorySearch_FLOAT(FLOAT, PMAPS); // Memory search FLOAT
+    PMAPS MemorySearch_DOUBLE(DOUBLE, PMAPS); // Memory Search DOUBLE
+    PMAPS MemorySearch_WORD(WORD, PMAPS); // Memory Search WORD
+    PMAPS MemorySearch_BYTE(BYTE, PMAPS); // Memory Search BYTE
+    PMAPS MemorySearch_QWORD(QWORD, PMAPS); // Memory Search QWORD
+
+    void MemoryOffset(char*, long int, int); // search offset
+    PMAPS MemoryOffset_DWORD(DWORD, long int, PMAPS); // search offset DWORD
+    PMAPS MemoryOffset_FLOAT(FLOAT, long int, PMAPS); // search offset FLOAT
+    PMAPS MemoryOffset_DOUBLE(DOUBLE, long int, PMAPS); // search offset DOUBLE
+    PMAPS MemoryOffset_WORD(WORD, long int, PMAPS); // search offset WORD
+    PMAPS MemoryOffset_BYTE(BYTE, long int, PMAPS); // search offset BYTE
+    PMAPS MemoryOffset_QWORD(QWORD, long int, PMAPS); // search offset QWORD
+
+    void RangeMemoryOffset(char*, char*, long int, int); // range offset
+    PMAPS RangeMemoryOffset_DWORD(DWORD, DWORD, long int, PMAPS); // range offset DWORD
+    PMAPS RangeMemoryOffset_FLOAT(FLOAT, FLOAT, long int, PMAPS); // range offset FLOAT
+    PMAPS RangeMemoryOffset_DOUBLE(DOUBLE, DOUBLE, long int, PMAPS); // range offset DOUBLE
+    PMAPS RangeMemoryOffset_WORD(WORD, WORD, long int, PMAPS); // range offset WORD
+    PMAPS RangeMemoryOffset_BYTE(BYTE, BYTE, long int, PMAPS); // range offset BYTE
+    PMAPS RangeMemoryOffset_QWORD(QWORD, QWORD, long int, PMAPS); // range offset QWORD
+
+    void MemoryWrite(char*, long int, int); // memory write
+    int MemoryWrite_DWORD(DWORD, PMAPS, long int); // memory write DWORD
+    int MemoryWrite_FLOAT(FLOAT, PMAPS, long int); // memory write FLOAT
+    int MemoryWrite_DOUBLE(DOUBLE, PMAPS, long int); // memory write DOUBLE
+    int MemoryWrite_WORD(WORD, PMAPS, long int); // memory write WORD
+    int MemoryWrite_BYTE(BYTE, PMAPS, long int); // memory write BYTE
+    int MemoryWrite_QWORD(QWORD, PMAPS, long int); // memory write QWORD
+
+
+    int WriteAddress(long int, char*, int); // Modify the value in the address
+    int WriteAddress_DWORD(ADDRESS, DWORD);
+    int WriteAddress_FLOAT(ADDRESS, FLOAT);
+    int WriteAddress_DOUBLE(ADDRESS, DOUBLE);
+    int WriteAddress_WORD(ADDRESS, WORD);
+    int WriteAddress_BYTE(ADDRESS, BYTE);
+    int WriteAddress_QWORD(ADDRESS, QWORD);
+
+    void PrintResults(); // Print the contents of Res
+    void ClearResults(); // Clear the linked list and free up space
+    void ClearMaps(PMAPS); // Clear maps
+    int GetResultCount(); //Get the number of search results
+
+    int isapkinstalled(char*); // Check if the app is installed
+    int isapkrunning(char*); // Check if the app is running
+    int killprocess(char*); // kill the process
+    char GetProcessState(char*); // Get process state
+    int killGG(); // kill the gg modifier
+    int killXs(); // kill xs
+    int uninstallapk(char*); // silently remove software
+    int installapk(char*); // silently uninstall the software
+    int rebootsystem(); // reboot the system (phone)
+    int PutDate(); // output system date
+    int GetDate(char*); // Get system time
+
+    PMAPS GetResults(); // Get the result, return the head pointer
+    int AddFreezeItem_All(char*, int, long int); // Freeze all results
+    int AddFreezeItem(long int, char*, int, long int); // add frozen data
+    int AddFreezeItem_DWORD(long int, char*); // DWORD
+    int AddFreezeItem_FLOAT(long int, char*); // FLOAT
+    int AddFreezeItem_DOUBLE(long int, char*); // DOUBLE
+    int AddFreezeItem_WORD(long int, char*); // WORD
+    int AddFreezeItem_BYTE(long int, char*); // BYTE
+    int AddFreezeItem_QWORD(long int, char*); // QWORD
+
+    int RemoveFreezeItem(long int); // clear fixed freeze data
+    int RemoveFreezeItem_All(); // clear all frozen data
+    int StartFreeze(); // start freezing
+    int StopFreeze(); // stop freezing
+    int SetFreezeDelay(long int); // set the freeze delay
+    int PrintFreezeItems(); // print the freeze list
+
+    char* GetAddressValue(ADDRESS, int);
+    DWORD GetAddressValue_DWORD(ADDRESS);
+    FLOAT GetAddressValue_FLOAT(ADDRESS);
+    DOUBLE GetAddressValue_DOUBLE(ADDRESS);
+    WORD GetAddressValue_WORD(ADDRESS);
+    BYTE GetAddressValue_BYTE(ADDRESS);
+    QWORD GetAddressValue_QWORD(ADDRESS);
+
+    char* getRightText(char*, char*, int);//Get the right text
+    bool getMask(long int, char*);//Judgment mask
+    void MaskSearch(char*, int);//Mask search
+
+    bool snowpd(long int);
+    long int GetModuleBase(char*, char*, int);
+    void FreezeThread();
+};
+
+
diff --git a/main.cpp b/main.cpp
index 5c7a20c..dc2aa9c 100644
--- a/main.cpp
+++ b/main.cpp
@@ -1,22 +1,22 @@
-#include <iostream>
-#include "MemoryTools.h"
-
-int main(int argc, char* argv[]) {
-    /* 1. Package Name of the game
-    2. ROOT_MODE (tells you are using rooted device (not reooted device not implimented yet))
-    */
-    MemoryTools memoryTools("com.tencent.ig", MODE_ROOT);
-    
-    // Initialize the search range to global (check other ranges in header file of memory tool)
-    memoryTools.SetSearchRange(ALL);
-    // Search for 1 in whole memory of type byte
-    memoryTools.MemorySearch("1", TYPE_BYTE);
-    // This is another usage if you want to write a value at given offset you can use below line else above line will write all the data in memory 
-    memoryTools.MemoryOffset("2", 2, /*offset*/ TYPE_BYTE);
-    // Finally write the value to the memory
-    memoryTools.MemoryWrite("0", 2, /*offset*/ TYPE_BYTE);
-    // clear results function clean all the offsets/values from memory
-    memoryTools.ClearResults();
-
-    return 0;
-}
+# include "MemoryTool.h"
+
+int main(int arc, char argv[]) {
+	/* 1. Package Name of the game
+	2. ROOT_MODE (tells you are using rooted device (not reooted device not implimented yet))
+	*/
+	char game_package[] = "com.tencent.ig";
+	MemoryTool memory_tool;
+	memory_tool.initXMemoryTools(game_package, MODE_ROOT);
+	
+	// Initialize the search range to global (check other ranges in header file of memory tool)
+	memory_tool.SetSearchRange(ALL);
+	// Search for 1 in whole memory of type byte
+	memory_tool.MemorySearch("1", TYPE_BYTE);
+	// This is another usage if you want to write a value at given offset you can use below line else above line will write all the data in memory 
+	memory_tool.MemoryOffset("2", 2, /*offset*/ TYPE_BYTE);
+	// Finally write the value to the memory
+	memory_tool.MemoryWrite("0", 2, /*offset*/ TYPE_BYTE);
+	// clear results function clean all the offsets/values from memory
+	memory_tool.ClearResults();
+	return 0;
+}