Ошибка Аргумент Типа const char* не совместим с параметром char*

#include <Windows.h>
#include <TlHelp32.h>
 
using namespace std;
 
typedef unsigned char uint8_t;
 
template<typename T, size_t N>
 
size_t countof(T(&array)[N])
{
    return N;
}
 
/* offset */
 
DWORD dwLocalPlayer;
DWORD dwEntityList;
DWORD dwGlow;
 
DWORD dwTeam = 0xF0;
DWORD dwDormant = 0xE9;
 
struct SModule
{
    DWORD dwBase;
    DWORD dwSize;
};
 
/* Debugger */
 
class debugger
{
private:
    DWORD pid;
    HANDLE Process;
public:
    bool Attach(char* process, DWORD rights = PROCESS_ALL_ACCESS)
    {
        HANDLE handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
        PROCESSENTRY32 entry;
        entry.dwSize = sizeof(entry);
        do
        {
            if (!strcmp(entry.szExeFile, process))
            {
                pid = entry.th32ProcessID;
                CloseHandle(handle);
                Process = OpenProcess(rights, false, pid);
                return true;
            }
        } while (Process32Next(handle, &entry));
        return false;
    }
    SModule GetModule(char* modulename) {
        HANDLE module = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, NULL);
        MODULEENTRY32 mEntry;
        mEntry.dwSize = sizeof(mEntry);
        do
        {
            if (!strcmp(mEntry.szModule, modulename))
            {
                SModule mod = { (DWORD)mEntry.hModule, mEntry.modBaseSize };
                return mod;
            }
        } while (Module32Next(module, &mEntry));
        return { (DWORD)false, (DWORD)false };
    }
    template<typename T>
    T Read(DWORD address) {
        T _read;
        ReadProcessMemory(Process, (LPVOID)address, &_read, sizeof(T), NULL);
        return _read;
    }
    template<typename T>
    void Write(DWORD address, T value) {
        WriteProcessMemory(Process, (LPVOID)address, &value, sizeof(T), NULL);
    }
 
    bool DataCompare(const BYTE* data, const BYTE* mask, LPCSTR szMask) {
        for (; *szMask; ++szMask, ++data, ++mask) {
            if (*szMask == 'x' && *data != *mask)
            {
                return false;
            }
        }
        return (*szMask = NULL); // Доделать
    }
 
    DWORD FindPattern(DWORD start, DWORD size, LPCSTR sig, LPCSTR mask) {
        BYTE* data = new BYTE[size];
        DWORD bytesread;
        if (!ReadProcessMemory(Process, (LPVOID)start, data, size, &bytesread))
        {
            return NULL;
        }
        for (DWORD i = 0; i < size; i++)
        {
            if (DataCompare((CONST BYTE*)(data + i), (CONST BYTE*)sig, mask))
            {
                return start + i;
            }
        }
        return NULL;
    }
 
    DWORD FindPatternArray(DWORD start, DWORD size, LPCSTR mask, int count, ...) {
        char* sig = new char[count + 1]; // 1 не точно
        va_list ap;
        va_start(ap, count);
        for (int i = 0; i < count; i++)
        {
            char read = va_arg(ap, char);
            sig[i] = read;
        }
        va_end(ap);
        sig[count] = '\0';
        return FindPattern(start, size, sig, mask);
    }
};
 
 
struct glow_t
{
    DWORD dwBase;
    float r, g, b, a;
    uint8_t unk[16];
    bool m_bRederWhenOccluded;
    bool m_bRenderWhenUnoccluded;
    bool m_bFullBloom;
    uint8_t unk2[10];
};
 
struct entity
{
    DWORD dwBase;
    int team;
    bool is_dowmant;
};
 
struct player
{
    DWORD dwBase;
    bool isDormant;
};
 
debugger memory;
SModule module;
int iFriendlies;
int iEnemies;
entity entEnemies[32];
entity entFriendlies[32];
entity me;
debugger* mem;
SModule moduleClient;
 
void update_local_player() {
    DWORD dwStart = memory.FindPatternArray(module.dwBase, module.dwSize, "xxx????xx????xxxxx?", 19, 0x8D, 0x34, 0x85, 0x0, 0x0, 0x0, 0x0, 0x89, 0x15, 0x0, 0x0, 0x0, 0x0, , 0x89, 0x41, 0x8, 0x88, 0x48, 0x0);
    DWORD dwP1 = memory.Read<DWORD>(dwStart + 3);
    DWORD dwP2 = memory.Read<DWORD>(dwStart + 18);
    dwLocalPlayer = (dwP1 + dwP2) - module.dwBase;
}
 
void update_entity_list() {
    DWORD dwStart = memory.FindPatternArray(module.dwBase, module.dwSize, "x????xx?xxx", 11, 0x5, 0x0, 0x0, 0x0, 0xC1, 0xE9, 0x0, 0x39, 0x48, 0x4, 0x0, 0x0, 0x0, , 0x89, 0x41, 0x8, 0x88, 0x48, 0x0);
    DWORD dwP1 = memory.Read<DWORD>(dwStart + 3);
    DWORD dwP2 = memory.Read<DWORD>(dwStart + 18);
    dwLocalPlayer = (dwP1 + dwP2) - module.dwBase;
}
 
void update_glow() {
    DWORD dwStart = memory.FindPatternArray(module.dwBase, module.dwSize, "xx????x????xxx????xx????xx", 27, 0x8D, 0x8F, 0, 0, 0, 0, 0xA1, 0, 0, 0, 0, 0xC7, 0x4, , 0x2, 0, 0, 0, 0, 0x89, 0x35, 0x0, 0x0, 0x0, 0x0, 0x88, 0x51);
    DWORD dwP1 = memory.Read<DWORD>(dwStart + 3);
    DWORD dwP2 = memory.Read<DWORD>(dwStart + 18);
    dwGlow = memory.Read<DWORD>(dwStart + 7) - module.dwBase;
}
 
void GetOffsets(debugger* d) {
    mem = d;
    moduleClient = mem->GetModule("client.dll");
    update_local_player();
    update_entity_list();
    update_glow();
}