// set flag to use random engine e.d random_device to #include <random>
// in true ||  false
// - true -- enable random_device and std::mt19997
// - false -- disable random_device random use C rand();
void setRandomEngineUsed(bool v) {
    bIsRandomEngineUsed = v;
    //std::cout << " (random_engine) enabled: " << (bIsRandomEngineUsed ? "true\n" : "false\n");
}
// random engine func 
// use: PahomEngine->math->random<type>(max_value,isCached);
// sample:
// int64_t i64ValueRandom = PahomEngine->math->random<int64_t>(255,false);
template <typename Tm>
Tm random(Tm value_max, bool bIsUseCachedRandom = false) {
    if(bIsRandomEngineUsed)
    {
        if (!bIsUseCachedRandom)
        {

            std::random_device rd_no_cached;
            std::mt19937 gen_no_cached(rd_no_cached());
            
            if constexpr (std::is_floating_point_v<Tm>) {
                std::uniform_real_distribution<Tm> dist(0, value_max);
                return dist(gen_no_cached);
            }
            else {
                std::uniform_int_distribution<Tm> dist(0, value_max);
                return dist(gen_no_cached);
            }
        }
        else {
            gen.seed(rd());
            if constexpr (std::is_floating_point_v<Tm>) {
                std::uniform_real_distribution<Tm> dist(0, value_max);
                return dist(gen);
            }
            else {
                std::uniform_int_distribution<Tm> dist(0, value_max);
                return dist(gen);
            }

        }
    }
    else {
        return static_cast<Tm>(rand() % (int)value_max);
    }
}

    template <typename In, typename Out>
    Out unicast(In value) {
        if constexpr (std::is_arithmetic_v<In> && std::is_arithmetic_v<Out>) {
            return static_cast<Out>(value);
        }
        else {
            std::string sv;
            if constexpr (std::is_convertible_v<In, std::string>) {
                sv = value;
            }

            Out result{};
            auto [ptr, ec] = std::from_chars(sv.data(), sv.data() + sv.size(), result);
            if (ec == std::errc::invalid_argument) {
                throw std::invalid_argument("unicast: not a number");
            }
            else if (ec == std::errc::result_out_of_range) {
                throw std::out_of_range("unicast: out of range");
            }

            return result;
        }
    }
};

   struct UniVec2 {
    T a, b;
    constexpr UniVec2() : a(), b() {}
    constexpr UniVec2(T _a, T _b) : a(_a), b(_b) {}
    size_t size() const {
        size_t out_size = sizeof(this->a) + sizeof(this->b);
        return out_size;
    }
};
struct d64Vec2 {
    double64_t x, y;
    constexpr d64Vec2() : x(0.0L), y(0.0L) {}
    constexpr d64Vec2(double64_t _x,double64_t _y) : x(_x), y(_y) {}
    constexpr size_t size() const {
        return sizeof(this->x) + sizeof(this->y);
    }
};
    UniVec2<UniVec2<d64Vec2>> vc42 = { {{3.43543,5.3453} ,{5.453453,5.5656353}},{{3.52426532,5.564645353},{5.76762424,6.455434545}} };
    d64Vec2 d64v2 = { 5.454354,4.21342 };