Функция поиска offset по hex значению в бинарном файле

static vector<uint8_t> hex2byte(const char *hex) {
    char high, low;
    vector<uint8_t> buf(strlen(hex) / 2);
    for (int i = 0, length = strlen(hex); i < length; i += 2) {
        high = toupper(hex[i]) - '0';
        low = toupper(hex[i + 1]) - '0';
        buf[i / 2] = ((high > 9 ? high - 7 : high) << 4) + (low > 9 ? low - 7 : low);
    }
    return buf;
}

#include <iostream>
#include <fstream>
#include <string.h>
#include <vector>
 
using namespace std;
 
///standart block function  -->
std::string &replaceAll(string &str, const string &from, const string &to) {
    if (!from.empty()) {
        size_t start_pos = 0;
        while ((start_pos = str.find(from, start_pos)) != string::npos) {
            str.replace(start_pos, from.length(), to);
            start_pos += to.length();
        }
    }
    return str;
}
 
static vector<char> hex2byte(const char *hex) {
    char high, low;
    vector<char> buf(strlen(hex) / 2);
    for (int i = 0, length = strlen(hex); i < length; i += 2) {
        high = toupper(hex[i]) - '0';
        low = toupper(hex[i + 1]) - '0';
        buf[i / 2] = ((high > 9 ? high - 7 : high) << 4) + (low > 9 ? low - 7 : low);
    }
    return buf;
}
///standart block function  <--
 
int find_offset(const char *file, const char *whatfind, const int course=0) {
    int block = 16777216; //16 Mb
    int offset_poz;
    vector<char> buff;
    buff.resize(block);
 
    string in(whatfind);
    if (in.find(" ") != string::npos) { //если есть пробелы - уберём
        in = replaceAll(in, " ", "");
    }
    whatfind = in.c_str();
    int len_whatfind = strlen(whatfind)/2; // размер того, что надо искать
    vector<char> data = hex2byte(whatfind);
    if (len_whatfind > block){ //ну мало ли
        block = len_whatfind;
        buff.resize(block);
    }
    fstream intput_file(file, ios::in | ios::binary);
    if (!intput_file.is_open()) {
        cerr << "File " << file << " not found" << endl;
        exit(2);
    }
    int size = intput_file.seekg(0,ios::end).tellg(); //размер файла
 
    if (course != 0 && size > block){ // напраление поиска: 0 - прямой, любое другое число - обратный
        intput_file.seekg(block,ios::end); //сразу идём в конец
    }else{
        intput_file.seekg(0,ios::beg);
    }
    while (!intput_file.eof()) {
        intput_file.read(buff.data(), block); //читаем кусок
 
        // чё тута?! как искать то?!
       // надо найти один вектор в другом
 
    }
    return offset_poz;
}
 
int main(int argc, char *argv[]) {
    int poz= find_offset("D:\\Old_system_MInt\\PycharmProjects\\untitled\\system-sign.img", "41 56 42 30");
    return 0;
}

#include <iostream>
#include <cstdio>
#include <cstring>
#include <memory>
 
#include <string.h> // memmem: GNU SOURCE macro needed
 
std::size_t findOffsetInFile(std::FILE* file, std::size_t size, char const* bytes, std::size_t len)
{
    std::unique_ptr<char[]> buffer( new char[size * 2] );
 
    std::size_t tSize = 0; // Total read bytes
    std::size_t fSize = std::fread(&buffer[0], 1, size, file);
    if(fSize >= len)
    {
        char* pBuf = &buffer[0];
        if(char* pFnd = (char*)::memmem(pBuf, fSize, bytes, len))
        {
            return std::distance(pBuf, pFnd);
        }
        tSize += fSize;
        while(std::size_t sSize = std::fread(&buffer[fSize], 1, size, file))
        {
            char* pBuf = &buffer[fSize];
            // Also here is the processing of the buffer boundary
            if(char* pFnd = (char*)::memmem(pBuf - len, sSize + len, bytes, len)) 
            {
                return tSize + std::distance(pBuf, pFnd);
            }
            if(sSize < len)
            {
                break; // There's no point to continue lookup
            }
            tSize += sSize;
            fSize  = sSize;
 
            std::memcpy(&buffer[0], pBuf, fSize);
        }
    }
    return -1; // Not found or error
}
 
int main()
{
    std::FILE* fin = std::fopen("test.djvu", "rb");
    if(fin)
    {
        // Byte sequence: 73 B9 15 87
        const char bytes[] = {'\x73', '\xB9', '\x15', '\x87'};
 
        // 256 - buffer size
        std::size_t off = findOffsetInFile(fin, 256, bytes, sizeof bytes); 
        std::cout << "Offset: " << off << std::endl;
 
        std::fclose(fin);
    }
}