void setSizeWindow(auto &engine) { 
     static int iSelected = 0, iHovered = -1; 
     static bool bSelected = 0; 
     for (int res = 0; res < std::size(engine->window_size_preset) - 1; res++) { 
         ImGui::SetCursorPosX(40.0f); 
         ImGui::ImLine(20, 20, iHovered == res || iSelected == res ? (iHovered == res ? engine->RGBA(0, 250, 155, 255) : engine->RGBA(255, 0, 155, 255)) : engine->RGBA(204, 204, 255, 255)); 
         ImGui::SameLine(); 
         engine->TextColored((iHovered == res ? engine->RGBA(130, 130, 155, 255) : engine->RGBA(204, 204, 255, 255)), "{}x{}", 
             engine->window_size_preset[res].first, engine->window_size_preset[res].second); 
         if (ImGui::IsItemHovered()) { 
             iHovered = res; 
         } 
         if (ImGui::IsItemClicked()) { 
             bSelected = true; 
             iSelected = res; 
             engine->SetSizeHWND(GetActiveWindow(), engine->window_size_preset[iSelected].first, engine->window_size_preset[iSelected].second); 
             engine->i64WindowSize[0] = engine->window_size_preset[iSelected].first; 
             engine->i64WindowSize[1] = engine->window_size_preset[iSelected].second; 
         } 
селектор разрешения в PahomEngine

auto foo = [](int a ,int b){return a+b;};
int a = 10,b = 5;
std::print("foo {} a:{} b{}",foo(a,b),a,b);

struct d{
int cnt = 0;
};
d data;
std::atomic_ref<int> at_data (data.cnt);


std::jthread th0 ([&]{at.data++;});
std::jthread th1 ([&]{at.data+=3;})

#include <format>
#include <stdint.h>
#include <chrono>
#include <vector>
#include <thread>
#include <iostream>
#include <print>
#include <atomic>
#include <random>
int call = 0;
std::atomic <int64_t> size_out = 0;
int thread_id = 0;
struct _rand {
    std::mt19937_64 mt;
    _rand() {
        std::random_device rd;
        mt.seed(rd());
    }
    template<typename T>
    T random(T min, T max) {
       std::uniform_int_distribution<std::int64_t> dist(min, max);
       return dist(mt);

    }
};
_rand mtrd;
void generate_password(int64_t size) {
  
    std::string sMask = "qwertyuiopasdfghjklzxcvbnm1234567890";
    std::string sOutPassword = "";

    // gen
    
    for (int64_t fillChars = 0; fillChars < size; fillChars++) {
        sOutPassword += sMask[mtrd.random<int>(0,sMask.size())];
        size_out.fetch_add(sOutPassword.size(), std::memory_order_relaxed);
    }
   
   
}

void bench(int64_t size) {
    auto in = std::chrono::high_resolution_clock::now();
    std::vector<std::jthread> jthreads;
    jthreads.reserve(std::jthread::hardware_concurrency());
    for (int i = 0; i < std::jthread::hardware_concurrency(); i++) {
        jthreads.emplace_back([=] {
            generate_password(size / std::jthread::hardware_concurrency());
            });

        if (jthreads[i].joinable()) {
            thread_id = jthreads[i].get_id()._Get_underlying_id();
            std::print("thread ({}) :: ({}) size: ({})\n", (std::to_string(call).size() < 2 ? std::format("0{}", call) : std::to_string(call)), thread_id, size_out.load());
            call++;

        }
        if (call >= std::jthread::hardware_concurrency()) {
            auto out = std::chrono::high_resolution_clock::now();
            std::cout << "----------------------\n out time : " << std::chrono::duration_cast<std::chrono::nanoseconds>(out - in).count() << " ns\n";
        }
    }
}
int main(int argc, char** argv) {
   
    int64_t i64MaxSize = (argc < 2 ? 10000000 : std::stoll(argv[1]));
    if (argc < 2) {
        std::print("argv[1] empty!\nset default size_buffer={}\n", i64MaxSize);
    }
    else {
        std::print("size_buffer={}\n", i64MaxSize);
    }
    uint32_t u32MaxThreads = std::jthread::hardware_concurrency();
    std::print("--------------------------------------\n");
    std::print("                                      \n");
    std::print("        CPU Bench by HCPP             \n");
    std::print("    max_cpu:{}         size:{}        \n", u32MaxThreads,i64MaxSize);
    std::print("--------------------------------------\n");
    bench(i64MaxSize);
    
    
}