WriteProcessMemory записывает ноль

 float a = 5;

std::uint32_t Find_Prossec(std::wstring obj) {
    PROCESSENTRY32 peProcessEntry;
    HANDLE CONST hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (INVALID_HANDLE_VALUE == hSnapshot) {
        return 0;
    }
 
    peProcessEntry.dwSize = sizeof(PROCESSENTRY32);
    Process32First(hSnapshot, &peProcessEntry);
    do {
        if (peProcessEntry.szExeFile == obj) {
            CloseHandle(hSnapshot);
            return  peProcessEntry.th32ProcessID;
        }
    } while (Process32Next(hSnapshot, &peProcessEntry));
 
    CloseHandle(hSnapshot);
    return 0;
}
 
std::int32_t Find_Module(std::wstring obj, std::int32_t ID) {
    HANDLE  ModuleSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, ID );
    if (INVALID_HANDLE_VALUE == ModuleSnap) {
        return 0;
    }
    MODULEENTRY32 me{ sizeof(me) };
    if ((Module32First(ModuleSnap, &me)) == FALSE){
        CloseHandle(ModuleSnap);
        return 0; 
    }
    do {
        if (me.szModule == obj) {
            CloseHandle(ModuleSnap);
            return  reinterpret_cast<std::uint32_t>(me.modBaseAddr); 
        }
    } while (Module32Next(ModuleSnap, &me));
 
    CloseHandle(ModuleSnap);
    return 0;
}
 
 
std::int32_t find_address(HANDLE hndl, std::uint32_t moduleAddress, const std::uint32_t offsets) {
    std::uint32_t prevAddress = moduleAddress;
    prevAddress += offsets;
 
    std::uint32_t readBuffer = 0;
    SIZE_T byteReadCount = 0;
    if (ReadProcessMemory(hndl, reinterpret_cast<void*>(prevAddress), &readBuffer, sizeof(readBuffer), NULL) == FALSE) {
        return 0;
    }
    //prevAddress = readBuffer; 
 
    
    return prevAddress; 
   
}
 
 
INT main() {
    HANDLE CONST hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
    std::int32_t ID = Find_Prossec(L"BABYTYPE.EXE");
    HANDLE hamachiHAndle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ID);
    std::int32_t baseAddress = Find_Module(L"BABYTYPE.EXE", ID);
 
    std::uint32_t lvl = find_address(hamachiHAndle, baseAddress, 0x4AE04);
 
    float  a = 5; 
    while (true) 
    {
         if (WriteProcessMemory(hamachiHAndle, reinterpret_cast<void*>(lvl), &a, sizeof(a), NULL) != 0) {
            std::cout << "Succeful!" << std::endl;
        }
        else {
            std::cout << "Error!" << std::endl;
        }
        std::this_thread::sleep_for(std::chrono::seconds(3)); 
 
    }
    
    return 0; 
}