[Source Code] copied delite's cheat

namespace console
{
        template<WORD attr = FOREGROUND_INTENSITY|FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE>
        inline auto Msg(const char* const format, ...)
        {
                char buffer[UNICODE_STRING_MAX_BYTES];

                va_list args;
                va_start(args, format);
                vsnprintf(buffer, sizeof(buffer), format, args);
                va_end(args);

                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), attr);
                WriteConsoleA(GetStdHandle(STD_OUTPUT_HANDLE), buffer, strlen(buffer), nullptr, nullptr);
        }
};

namespace memory_info
{
        std::vector<uintptr_t> search(const std::string& strPattern,
                uintptr_t start,
                uintptr_t end);
};

namespace memory_info
{
    std::vector<uintptr_t> search(const std::string& strPattern,
                                  uintptr_t start,
                                  uintptr_t end)
    {
        std::vector<uintptr_t> result;

        auto ldConv = [](char c1, char c2) {
            auto validChar = [](char& c) {
                auto ci = std::toupper(c);

                if ((ci > 57 && ci < 65) || (ci < 48 || ci > 71))
                {
                    return false;
                }

                // 48 49 50 51 52 53 54 55 56 57 65 66 67 68 69 70 71
                // 0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F  G
                // 65 - 10
                if (ci > 57)
                    ci -= 55;
                else
                    ci -= 48;

                c = static_cast<char>(ci);

                return true;
            };

            if (!validChar(c2) || !validChar(c1))
                assert("Not a hex code");

            return static_cast<uint8_t>(c2 + c1 * 0x10);
        };

        for (auto addr = start; addr != end;)
        {
            auto nextByte = reinterpret_cast<uint8_t*>(addr);

            for (size_t patternIndex = 0; patternIndex < strPattern.length();
                 patternIndex += 3)
            {
                if (strPattern[patternIndex] != '?' &&
                    strPattern[patternIndex + 1] != '?')
                {
                    if (*nextByte != ldConv(strPattern[patternIndex],
                                            strPattern[patternIndex + 1]))
                        goto not_match;
                }

                nextByte++;
            }

            result.push_back(addr);
            break;

        not_match:
            addr++;
        }

        return result;
    }
};