for (auto d : wstr)
    {
        uint32_t number = (uint32_t)d - (uint32_t)'0';
        if (number <= 9)
        {
            res = res * 10 + number;
        }
        else
        {
            throw std::out_of_range("'" + std::to_string(d) + "': Symbol is out of range");
        }
    }

#include <iostream>
#include <vector>
#include <string>
#include <chrono>
#include <random>

using Int = int32_t;

std::vector<std::wstring> MakeIntSequence(size_t size)
{
   std::random_device rd;  //Will be used to obtain a seed for the random number engine
   std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
   std::uniform_int_distribution<> distrib(0, std::numeric_limits<int32_t>::max());
   std::vector<std::wstring> v;
   v.reserve(size);
   for (size_t i = 0; i < size; ++i)
   {
      v.push_back(std::to_wstring(distrib(gen)));
   }
   return v;
}

Int ParseInt(const std::wstring& wstr)
{
   Int res{};
   for (auto&& d : wstr)
   {
      if ('0' <= d && d <= '9')
      {
         res = res * 10 + d - '0';
      }
      else
      {
         throw std::out_of_range("'" + std::to_string(d) + "': Symbol is out of range");
      }
   }
   return res;
}

void testDistributionInMemory(const std::vector<std::wstring>& v)
{
   if (v.size() >= 2)
   {
      std::intptr_t minInterval = std::numeric_limits<std::intptr_t>::max();
      std::intptr_t maxInterval{};
      const wchar_t* prev = v[0].data();

      for (size_t i = 1; i < v.size(); ++i)
      {
         const wchar_t* next = v[i].data();
         std::intptr_t nextInterval = next - prev;
         if (minInterval > nextInterval)
         {
            minInterval = nextInterval;
         }
         if (maxInterval < nextInterval)
         {
            maxInterval = nextInterval;
         }
         prev = next;
      }
      std::cout << "[Distribution in memory]: Min Interval: " << minInterval << ", Max Interval: " << maxInterval << std::endl;
   }
}

int main()
try
{
   namespace tm = std::chrono;

   const auto vals = MakeIntSequence(0x4000000);

   const auto t0 = tm::steady_clock::now();

   Int hash{};
   for (const auto& val : vals)
   {
      hash ^= ParseInt(val);
   }
   const tm::duration<double> dt = tm::steady_clock::now() - t0;

   std::cout << "Hash = " << std::hex << hash << std::dec << std::endl;
   std::cout << "Processing time: " << dt.count() << " sec" << std::endl;
   testDistributionInMemory(vals);
}
catch (const std::exception& ex)
{
   std::cerr << "[Unhandled Exception]: " << ex.what() << std::endl;
}

import random
import sys
import time

def make_int_seq(cnt):
    res = []
    for _ in range(cnt):
        s = str(random.randint(0, 0xffffffff))
        res.append(s)
    return res

def get_hash(strs):
    hash = 0
    for s in strs:
        i = int(s)
        hash ^= i
    return hash
   
   
if len(sys.argv) < 2:
    pritn("usage: program N")
    sys.exit(1)
    
cnt = int(sys.argv[1])

t1 = time.time()
strs = make_int_seq(cnt)

t2 = time.time()

h = get_hash(strs)
t3 = time.time()

print(f"make strings: {(t2 - t1)*1000:.0f} ms")
print(f"hash = {h}. calc time: {(t3 - t2)*1000:.0f} ms")