strexpr.h

/*
 * ver. 2.1.3
 * (c) Проект "SimStr", Александр Орефков orefkov@gmail.com
 * База для строковых конкатенаций через выражения времени компиляции
 * (c) Project "SimStr", Aleksandr Orefkov orefkov@gmail.com
 * Base for string concatenations via compile-time expressions
 */
#pragma once
#include <cstddef>
#include <cstdint>
#include <climits>
#include <limits>
#include <string>
#include <string_view>
#include <concepts>
#include <vector>
#include <optional>
#include <charconv>
#include <array>
 
#if defined __has_builtin
#  if __has_builtin(__builtin_mul_overflow) && __has_builtin(__builtin_add_overflow)
#    define HAS_BUILTIN_OVERFLOW
#  endif
#endif
 
#ifdef _MSC_VER
#define _no_unique_address msvc::no_unique_address
#define decl_empty_bases __declspec(empty_bases)
#else
#define _no_unique_address no_unique_address
#define decl_empty_bases
#endif
 
#ifdef _MSC_VER
/* MSVC иногда не может сделать "text"_ss consteval, выдает ошибку C7595.
Находил подобное https://developercommunity.visualstudio.com/t/User-defined-literals-not-constant-expre/10108165
Пишут, что баг исправлен, но видимо не до конца.
Без этого в тестах в двух местах не понимает "text"_ss, хотя в других местах - нормально работает*/
/* MSVC sometimes fails to do "text"_ss consteval and gives error C7595.
Found something like this https://developercommunity.visualstudio.com/t/User-defined-literals-not-constant-expre/10108165
They write that the bug has been fixed, but apparently not completely.
Without this, in tests in two places it does not understand “text”_ss, although in other places it works fine */
#define SS_CONSTEVAL constexpr
#else
#define SS_CONSTEVAL consteval
#endif

namespace simstr {
 
// Выводим типы для 16 и 32 битных символов в зависимости от размера wchar_t
// Infer types for 16 and 32 bit characters depending on the size of wchar_t
inline constexpr bool wchar_is_u16 = sizeof(wchar_t) == sizeof(char16_t);
 
using wchar_type = std::conditional<wchar_is_u16, char16_t, char32_t>::type;
 
inline wchar_type* to_w(wchar_t* p) {
    return (reinterpret_cast<wchar_type*>(p));
}
 
inline const wchar_type* to_w(const wchar_t* p) {
    return (reinterpret_cast<const wchar_type*>(p));
}
 
inline wchar_t* from_w(wchar_type* p) {
    return (reinterpret_cast<wchar_t*>(p));
}
 
inline const wchar_t* from_w(const wchar_type* p) {
    return (reinterpret_cast<const wchar_t*>(p));
}
 
using u8s = char;
using ubs = char8_t;
using uws = wchar_t;
using u16s = char16_t;
using u32s = char32_t;
 
using uu8s = std::make_unsigned<u8s>::type;
 
template<typename T, typename K = void, typename... Types>
struct is_one_of_type {
    static constexpr bool value = std::is_same_v<T, K> || is_one_of_type<T, Types...>::value;
};
template<typename T>
struct is_one_of_type<T, void> : std::false_type {};
 
template<typename K>
concept is_one_of_char_v = is_one_of_type<K, u8s, ubs, wchar_t, u16s, u32s>::value;
 
template<typename K>
concept is_one_of_std_char_v = is_one_of_type<K, u8s, ubs, wchar_t, wchar_type>::value;
 
template<is_one_of_std_char_v From>
auto to_one_of_std_char(From* from) {
    if constexpr (std::is_same_v<From, u8s> || std::is_same_v<From, wchar_t>) {
        return from;
    } else if constexpr (std::is_same_v<From, ubs>) {
        return reinterpret_cast<u8s*>(from);
    } else {
        return from_w(from);
    }
}
 
template<is_one_of_std_char_v From>
auto to_one_of_std_char(const From* from) {
    if constexpr (std::is_same_v<From, u8s> || std::is_same_v<From, wchar_t>) {
        return from;
    } else if constexpr (std::is_same_v<From, ubs>) {
        return reinterpret_cast<const u8s*>(from);
    } else {
        return from_w(from);
    }
}
 
template<typename K>
struct to_std_char_type : std::type_identity<K>{};
 
template<>
struct to_std_char_type<char8_t>{
    using type = char;
};
 
template<>
struct to_std_char_type<char16_t>{
    using type = std::conditional_t<sizeof(char16_t) == sizeof(wchar_t), wchar_t, void>;
};
 
template<>
struct to_std_char_type<char32_t>{
    using type = std::conditional_t<sizeof(char32_t) == sizeof(wchar_t), wchar_t, void>;
};
 
template<typename K>
using to_std_char_t = typename to_std_char_type<K>::type;
 
template<typename K>
struct to_base_char_type : std::type_identity<K>{};
 
template<>
struct to_base_char_type<char8_t>{
    using type = char;
};
 
template<>
struct to_base_char_type<wchar_t>{
    using type = std::conditional_t<sizeof(char16_t) == sizeof(wchar_t), char16_t, char32_t>;
};
 
template<typename K>
using to_base_char_t = typename to_base_char_type<K>::type;

template<typename K1, typename K2>
concept is_equal_str_type_v = sizeof(K1) == sizeof(K2) && is_one_of_char_v<K1> && is_one_of_char_v<K2>;
 
/*
Вспомогательные шаблоны для определения строковых литералов.
Используются для того, чтобы в параметрах функций ограничивать типы строго как `const K(&)[N]`
Если пишем
template<size_t N>
void func(const char(&lit)[N]);
то в такую функцию можно будет передать не константный буфер, что может вызывать ошибку:
 
// Выделили место под символы
char buf[100];
// Как то наполнили буфер, допустим, до половины.
 
stringa text = buf;
Тут компилятор приведет buf из типа char[100] в тип const char[100] и вызовет конструктор
для строкового литерала, в text запишется просто указатель на buf и длина 100.
 
Поэтому такие параметры объявляем как
template<typename T, typename K = typename const_lit<T>::symb_type, size_t N = const_lit<T>::Count>
void func(T&& lit);
 
Тогда компилятор будет подставлять для T точный тип параметра без попыток привести тип к другому типу,
и выражение с параметром char[100] - не скомпилируется.
 
Helper templates for defining string literals.
They are used to limit types in function parameters strictly as `const K(&)[N]`
If we write
template<size_t N>
void func(const char(&lit)[N]);
then it will be possible to pass a non-constant buffer to such a function, which may cause an error:
 
// Allocate space for symbols
char buf[100];
// Somehow the buffer was filled, say, to half.
 
stringa text = buf;
Here the compiler will convert buf from type char[100] to type const char[100] and call the constructor
for a string literal, text will simply contain a pointer to buf and length 100.
 
Therefore, we declare such parameters as
template<typename T, typename K = typename const_lit<T>::symb_type, size_t N = const_lit<T>::Count>
void func(T&& lit);
 
Then the compiler will substitute for T the exact type of the parameter without attempting to cast the type to another type,
and an expression with the char[100] parameter will not compile.
*/
 
template<typename T> struct const_lit; // sfinae отработает, так как не найдёт определения | sfinae will work because it won't find a definition
// Для правильных типов параметров есть определение, в виде специализации шаблона
// There is a definition for the correct parameter types, in the form of a template specialization
template<is_one_of_char_v T, size_t N>
struct const_lit<const T(&)[N]> {
    using symb_type = T;
    constexpr static size_t Count = N;
};
 
template<typename T>
concept is_const_lit_v = requires {
    typename const_lit<T>::symb_type;
};
 
// Тут ещё дополнительно ограничиваем тип литерала
// Here we further restrict the type of the literal
template<typename K, typename T> struct const_lit_for;
 
template<typename K, is_equal_str_type_v<K> P, size_t N>
struct const_lit_for<K, const P(&)[N]> {
    constexpr static size_t Count = N;
};
 
template<typename K, size_t N>
class const_lit_to_array {
 
    template<size_t Idx>
    constexpr size_t find(K s) const {
        if constexpr (Idx < N) {
            return s == symbols_[Idx] ? Idx : find<Idx + 1>(s);
        }
        return -1;
    }
 
    template<size_t Idx>
    constexpr bool exist(K s) const {
        if constexpr (Idx < N) {
            return s == symbols_[Idx] || exist<Idx + 1>(s);
        }
        return false;
    }
public:
    const K (&symbols_)[N + 1];
 
    template<typename T, size_t M = const_lit_for<K, T>::Count> requires (M == N + 1)
    constexpr const_lit_to_array(T&& s)
        : symbols_((const K(&)[M])s) {}
 
    constexpr bool contain(K s) const {
        return exist<0>(s);
    }
    constexpr size_t index_of(K s) const {
        return find<0>(s);
    }
};
 
template<typename A>
concept StrTypeCommon = requires(const A& a) {
    typename std::remove_cvref_t<A>::symb_type;
    { a.is_empty() } -> std::same_as<bool>;
    { a.length() } -> std::convertible_to<size_t>;
    { a.symbols() };
};
 
template<typename A>
concept HasSymbType = requires {
    typename std::remove_cvref_t<A>::symb_type;
};

template<typename A, typename K>
concept StrType = StrTypeCommon<A> && requires(const A& a) {
    { a.symbols() } -> std::same_as<const K*>;
} && std::is_same_v<typename std::remove_cvref_t<A>::symb_type, K>;
 
template<typename T> struct is_std_string_source : std::false_type{};
 
template<typename K, typename A>
struct is_std_string_source<std::basic_string<K, std::char_traits<K>, A>> : std::true_type{};
 
template<typename K>
struct is_std_string_source<std::basic_string_view<K, std::char_traits<K>>> : std::true_type{};
 
template<typename T>
concept is_std_string_source_v = is_std_string_source<T>::value;
 
template<typename T>
concept StdStrSource = is_std_string_source_v<std::remove_cvref_t<T>>;
 
template<typename T, typename K>
concept StdStrSourceForType = StdStrSource<T> && is_equal_str_type_v<K, typename T::value_type>;
 
template<typename T>
concept StrSource = StdStrSource<T> || is_const_lit_v<T> || StrTypeCommon<T>;
 
template<typename T>
concept StrSourceNoLiteral = StdStrSource<T> || StrTypeCommon<T>;
 
template<typename T> struct is_std_string : std::false_type{};
 
template<typename K, typename A>
struct is_std_string<std::basic_string<K, std::char_traits<K>, A>> : std::true_type{};
 
template<typename T>
concept is_std_string_v = is_std_string<T>::value;
template<typename T, typename K>
concept StdStringForType = is_std_string_v<T> && is_equal_str_type_v<K, typename T::value_type>;
 
template<typename T>
struct symb_type_from_src {
    using type = void;
};
 
template<typename K, size_t N>
struct symb_type_from_src<const K(&)[N]> {
    using type = K;
};
 
template<StdStrSource T>
struct symb_type_from_src<T> {
    using type = typename std::remove_cvref_t<T>::value_type;
};
 
template<HasSymbType T>
struct symb_type_from_src<T> {
    using type = typename std::remove_cvref_t<T>::symb_type;
};
 
template<typename T>
using symb_type_from_src_t = symb_type_from_src<T>::type;
 


template<typename A>
concept StrExpr = requires(const A& a) {
    typename std::remove_cvref_t<A>::symb_type;
    { a.length() } -> std::convertible_to<size_t>;
    { a.place(std::declval<typename std::remove_cvref_t<A>::symb_type*>()) } -> std::same_as<typename std::remove_cvref_t<A>::symb_type*>;
};

template<typename A, typename K>
concept StrExprForType = StrExpr<A> && is_equal_str_type_v<K, typename std::remove_cvref_t<A>::symb_type>;
 
template<typename K, typename T>
struct convert_to_strexpr;
 
template<typename A, typename K>
concept strexpr_from = requires(const A& a) {
    {convert_to_strexpr<K, std::remove_cvref_t<A>>::convert(a)} -> StrExprForType<K>;
};
 
template<typename A, typename K>
concept strexpr_std = requires(const A& a) {
    {convert_to_strexpr<K, std::remove_cvref_t<A>>::convert(a)} -> StdStringForType<K>;
};
 
template<typename A, typename K>
concept strexpr_for = StrExprForType<typename convert_to_strexpr<K, std::remove_cvref_t<A>>::type, K>;
 
template<typename A, typename K>
concept to_strexpr_type = StrExprForType<typename std::remove_cvref_t<A>::strexpr, K>;
 
template<typename A, typename K>
concept to_strexpr_meth = requires(const A& a) {
    {a.template to_strexpr<K>()} -> StrExprForType<K>;
};
 
template<typename A, typename K>
concept to_strexpr_std = requires(const A& a) {
    {a.template to_strexpr<K>()} -> StdStringForType<K>;
};
 
template<typename A, typename K>
concept convertible_to_strexpr = strexpr_for<A, K> || strexpr_from<A, K> || strexpr_std<A, K> || to_strexpr_type<A, K> || to_strexpr_meth<A, K> || to_strexpr_std<A, K>;
 
template<typename K, strexpr_from<K> T>
constexpr auto to_strexpr(T&& t) {
    return convert_to_strexpr<K, std::remove_cvref_t<T>>::convert(std::forward<T>(t));
}
 
template<typename K, strexpr_for<K> T>
constexpr typename convert_to_strexpr<K, std::remove_cvref_t<T>>::type to_strexpr(T&& t) {
    return {std::forward<T>(t)};
}
 
template<typename K, to_strexpr_type<K> T>
constexpr typename std::remove_cvref_t<T>::strexpr to_strexpr(T&& t) {
    return {std::forward<T>(t)};
}
 
template<typename K, to_strexpr_meth<K> T>
constexpr auto to_strexpr(T&& t) {
    return t.template to_strexpr<K>();
}
 
template<typename K, StdStrSource T> requires is_equal_str_type_v<K, typename T::value_type>
struct expr_stdstr_c {
    using symb_type = K;
    T t_;
 
    expr_stdstr_c(T t) : t_(std::move(t)){}
 
    constexpr size_t length() const noexcept {
        return t_.length();
    }
    constexpr symb_type* place(symb_type* p) const noexcept {
        size_t s = t_.size();
        std::char_traits<K>::copy(p, (const K*)t_.data(), s);
        return p + s;
    }
};
 
template<typename K, strexpr_std<K> T>
constexpr auto to_strexpr(T&& t) {
    using type = decltype(convert_to_strexpr<K, std::remove_cvref_t<T>>::convert(std::forward<T>(t)));
    return expr_stdstr_c<K, type>{convert_to_strexpr<K, std::remove_cvref_t<T>>::convert(std::forward<T>(t))};
}
 
template<typename K, to_strexpr_std<K> T>
constexpr auto to_strexpr(T&& t) {
    using type = decltype(t.template to_strexpr<K>());
    return expr_stdstr_c<K, type>{t.template to_strexpr<K>()};
}
 
template<typename K, typename T>
using convert_to_strexpr_t = decltype(to_strexpr<K>(std::declval<T>()));
 
/*
* Шаблонные классы для создания строковых выражений из нескольких источников.
* Благодаря компиляторно-шаблонной "магии" позволяют максимально эффективно
* получать результирующую строку - сначала вычисляется длина результирующей строки,
* потом один раз выделяется память для результата, после символы помещаются в
* выделенную память.
* Для конкатенация двух объектов строковых выражений в один
 
* Template classes for creating string expressions from multiple sources.
* Thanks to compiler-template "magic" they allow you to maximize efficiency
* get the resulting string - first the length of the resulting string is calculated,
* then memory is allocated once for the result, after which the characters are placed in
* allocated memory.
* For concatenating two string expression objects into one.
*/
 
template<typename K, typename Allocator, StrExprForType<K> A>
constexpr std::basic_string<K, std::char_traits<K>, Allocator> to_std_string(const A& expr) {
    std::basic_string<K, std::char_traits<K>, Allocator> res;
    if (size_t l = expr.length()) {
        auto fill = [&](K* ptr, size_t size) -> size_t {
            expr.place((typename A::symb_type*)ptr);
            return l;
        };
        if constexpr (requires { res.resize_and_overwrite(l, fill); }) {
            res.resize_and_overwrite(l, fill);
        } else if constexpr (requires{ res._Resize_and_overwrite(l, fill); }) {
            // Work in MSVC std lib before C++23
            res._Resize_and_overwrite(l, fill);
        } else {
            res.resize(l);  // bad, fill by 0 first.
            expr.place((typename A::symb_type*)res.data());
        }
    }
    return res;
}

template<typename Impl>
struct expr_to_std_string {
    template<is_equal_str_type_v<typename Impl::symb_type> P, typename Allocator>
    constexpr operator std::basic_string<P, std::char_traits<P>, Allocator>() const {
        return to_std_string<P, Allocator>(*static_cast<const Impl*>(this));
    }
};

template<StrExpr A, StrExprForType<typename A::symb_type> B>
struct strexprjoin : expr_to_std_string<strexprjoin<A, B>>{
    using symb_type = typename A::symb_type;
    const A& a;
    const B& b;
    constexpr strexprjoin(const A& a_, const B& b_) : a(a_), b(b_){}
    constexpr size_t length() const noexcept {
        return a.length() + b.length();
    }
    constexpr symb_type* place(symb_type* p) const noexcept {
        return (symb_type*)b.place((typename B::symb_type*)a.place(p));
    }
};

template<StrExpr A, StrExprForType<typename A::symb_type> B>
constexpr strexprjoin<A, B> operator+(const A& a, const B& b) {
    return {a, b};
}

template<StrExpr A, StrExprForType<typename A::symb_type> B, bool last = true>
struct strexprjoin_c : expr_to_std_string<strexprjoin_c<A, B, last>>{
    using symb_type = typename A::symb_type;
    const A& a;
    B b;
    template<typename... Args> requires (std::is_constructible_v<B, Args...>)
    constexpr strexprjoin_c(const A& a_, Args&&... args_) : a(a_), b(std::forward<Args>(args_)...) {}
    constexpr size_t length() const noexcept {
        return a.length() + b.length();
    }
    constexpr symb_type* place(symb_type* p) const noexcept {
        if constexpr (last) {
            return (symb_type*)b.place((typename B::symb_type*)a.place(p));
        } else {
            return a.place((symb_type*)b.place((typename B::symb_type*)p));
        }
    }
};

template<StrExpr A, convertible_to_strexpr<typename A::symb_type> B>
inline constexpr strexprjoin_c<A, convert_to_strexpr_t<typename A::symb_type, B>, true> operator+(const A& a, B&& b) {
    return {a, to_strexpr<typename A::symb_type>(std::forward<B>(b))};
}

template<StrExpr A, convertible_to_strexpr<typename A::symb_type> B>
inline constexpr strexprjoin_c<A, convert_to_strexpr_t<typename A::symb_type, B>, false> operator+(B&& b, const A& a) {
    return {a, to_strexpr<typename A::symb_type>(std::forward<B>(b))};
}

template<typename K>
struct empty_expr : expr_to_std_string<empty_expr<K>>{
    using symb_type = K;
    constexpr size_t length() const noexcept {
        return 0;
    }
    constexpr symb_type* place(symb_type* p) const noexcept {
        return p;
    }
};

inline constexpr empty_expr<u8s> eea{};
inline constexpr empty_expr<ubs> eeb{};
inline constexpr empty_expr<uws> eew{};
inline constexpr empty_expr<u16s> eeu{};
inline constexpr empty_expr<u32s> eeuu{};
 
template<typename K>
struct expr_char : expr_to_std_string<expr_char<K>>{
    using symb_type = K;
    K value;
    constexpr expr_char(K v) : value(v){}
    constexpr size_t length() const noexcept {
        return 1;
    }
    constexpr symb_type* place(symb_type* p) const noexcept {
        *p++ = value;
        return p;
    }
};

template<typename K, StrExprForType<K> A>
constexpr strexprjoin_c<A, expr_char<K>> operator+(const A& a, K s) {
    return {a, s};
}

template<typename K>
constexpr expr_char<K> e_char(K s) {
    return {s};
}
 
template<typename K, size_t N>
struct expr_literal : expr_to_std_string<expr_literal<K, N>> {
    using symb_type = K;
    const K (&str)[N + 1];
    constexpr expr_literal(const K (&str_)[N + 1]) : str(str_){}
 
    constexpr size_t length() const noexcept {
        return N;
    }
    constexpr symb_type* place(symb_type* p) const noexcept {
        if constexpr (N != 0)
            std::char_traits<K>::copy(p, str, N);
        return p + N;
    }
};

template<typename T, size_t N = const_lit<T>::Count>
constexpr expr_literal<typename const_lit<T>::symb_type, static_cast<size_t>(N - 1)> e_t(T&& s) {
    return {s};
}
 
template<bool first, typename K, size_t N, typename A>
struct expr_literal_join : expr_to_std_string<expr_literal_join<first, K, N, A>> {
    using symb_type = K;
    using atype = typename A::symb_type;
    const K (&str)[N + 1];
    const A& a;
    constexpr expr_literal_join(const K (&str_)[N + 1], const A& a_) : str(str_), a(a_){}
 
    constexpr size_t length() const noexcept {
        return N + a.length();
    }
    constexpr symb_type* place(symb_type* p) const noexcept {
        if constexpr (N != 0) {
            if constexpr (first) {
                std::char_traits<K>::copy(p, str, N);
                return (symb_type*)a.place((atype*)(p + N));
            } else {
                p = (symb_type*)a.place((atype*)p);
                std::char_traits<K>::copy(p, str, N);
                return p + N;
            }
        } else {
            return (symb_type*)a.place((atype*)p);
        }
    }
};

template<StrExpr A, typename T, typename P = typename const_lit<T>::symb_type, size_t N = const_lit<T>::Count> requires is_equal_str_type_v<typename A::symb_type, P>
constexpr expr_literal_join<false, P, (N - 1), A> operator+(const A& a, T&& s) {
    return {s, a};
}

template<StrExpr A, typename T, typename P = typename const_lit<T>::symb_type, size_t N = const_lit<T>::Count> requires is_equal_str_type_v<typename A::symb_type, P>
constexpr expr_literal_join<true, P, (N - 1), A> operator+(T&& s, const A& a) {
    return {s, a};
}

template<typename K, size_t N, size_t S = ' '>
struct expr_spaces : expr_to_std_string<expr_spaces<K, N, S>> {
    using symb_type = K;
    constexpr size_t length() const noexcept {
        return N;
    }
    constexpr symb_type* place(symb_type* p) const noexcept {
        if constexpr (N != 0)
            std::char_traits<K>::assign(p, N, static_cast<K>(S));
        return p + N;
    }
};

template<size_t N>
constexpr expr_spaces<u8s, N> e_spca() {
    return {};
}

template<size_t N>
constexpr expr_spaces<uws, N> e_spcw() {
    return {};
}

template<typename K>
struct expr_pad : expr_to_std_string<expr_pad<K>> {
    using symb_type = K;
    size_t len;
    K s;
    constexpr expr_pad(size_t len_, K s_) : len(len_), s(s_){}
    constexpr size_t length() const noexcept {
        return len;
    }
    constexpr symb_type* place(symb_type* p) const noexcept {
        if (len)
            std::char_traits<K>::assign(p, len, s);
        return p + len;
    }
};

template<typename K>
constexpr expr_pad<K> e_c(size_t l, K s) {
    return { l, s };
}
 
template<typename K, size_t N>
struct expr_repeat_lit : expr_to_std_string<expr_repeat_lit<K, N>> {
    using symb_type = K;
    size_t repeat_;
    const K (&s)[N + 1];
    constexpr expr_repeat_lit(size_t repeat, const K (&s_)[N + 1]) : repeat_(repeat), s(s_){}
    constexpr size_t length() const noexcept {
        return N * repeat_;
    }
    constexpr symb_type* place(symb_type* p) const noexcept {
        if constexpr (N) {
            for (size_t i = 0; i < repeat_; i++) {
                std::char_traits<K>::copy(p, s, N);
                p += N;
            }
        }
        return p;
    }
};
 
template<StrExpr A>
struct expr_repeat_expr : expr_to_std_string<expr_repeat_expr<A>> {
    using symb_type = typename A::symb_type;
    size_t repeat_;
    const A& expr_;
    mutable size_t len_;
    constexpr expr_repeat_expr(size_t repeat, const A& expr) : repeat_(repeat), expr_(expr){}
    constexpr size_t length() const noexcept {
        if (repeat_) {
            len_ = expr_.length();
            return repeat_ * len_;
        }
        return len_ = 0;
    }
    constexpr symb_type* place(symb_type* p) const noexcept {
        if (repeat_ && len_) {
            symb_type* start = p;
            p = expr_.place(p);
            for (size_t i = repeat_; --i; ) {
                std::char_traits<symb_type>::copy(p, start, len_);
                p += len_;
            }
        }
        return p;
    }
};

template<typename T, typename K = const_lit<T>::symb_type, size_t M = const_lit<T>::Count> requires (M > 0)
constexpr expr_repeat_lit<K, M - 1> e_repeat(T&& s, size_t l) {
    return { l, s };
}

template<StrExpr A>
constexpr expr_repeat_expr<A> e_repeat(const A& s, size_t l) {
    return { l, s };
}

template<StrExpr A, StrExprForType<typename A::symb_type> B>
struct expr_choice : expr_to_std_string<expr_choice<A, B>> {
    using symb_type = typename A::symb_type;
    using my_type = expr_choice<A, B>;
    const A& a;
    const B& b;
    bool choice;
 
    constexpr expr_choice(const A& _a, const B& _b, bool _choice) : a(_a), b(_b), choice(_choice){}
 
    constexpr size_t length() const noexcept {
        return choice ? a.length() : b.length();
    }
    constexpr symb_type* place(symb_type* ptr) const noexcept {
        return choice ? a.place(ptr) : (symb_type*)b.place((typename B::symb_type*)ptr);
    }
};

template<StrExpr A>
struct expr_if : expr_to_std_string<expr_if<A>> {
    using symb_type = typename A::symb_type;
    using my_type = expr_if<A>;
    const A& a;
    bool choice;
    constexpr expr_if(const A& _a, bool _choice) : a(_a), choice(_choice){}
 
    constexpr size_t length() const noexcept {
        return choice ? a.length() : 0;
    }
    constexpr symb_type* place(symb_type* ptr) const noexcept {
        return choice ? a.place(ptr) : ptr;
    }
};

template<typename L, StrExprForType<L> A, size_t N, bool Compare>
struct expr_choice_one_lit : expr_to_std_string<expr_choice_one_lit<L, A, N, Compare>> {
    using symb_type = L;
    const symb_type (&str)[N + 1];
    const A& a;
    bool choice;
    constexpr expr_choice_one_lit(const symb_type (&_str)[N + 1], const A& _a, bool _choice) : str(_str), a(_a), choice(_choice){}
 
    constexpr size_t length() const noexcept {
        return choice == Compare ? a.length() : N;
    }
    constexpr symb_type* place(symb_type* ptr) const noexcept {
        if (choice == Compare) {
            return (L*)a.place((typename A::symb_type*)ptr);
        }
        if constexpr (N != 0) {
            std::char_traits<symb_type>::copy(ptr, str, N);
        }
        return ptr + N;
    }
};

template<typename K, size_t N, typename P, size_t M>
struct expr_choice_two_lit : expr_to_std_string<expr_choice_two_lit<K, N, P, M>> {
    using symb_type = K;
    const K (&str_a)[N + 1];
    const P (&str_b)[M + 1];
    bool choice;
    constexpr expr_choice_two_lit(const K(&_str_a)[N + 1], const P(&_str_b)[M + 1], bool _choice)
        : str_a(_str_a), str_b(_str_b), choice(_choice){}
 
    constexpr size_t length() const noexcept {
        return choice ? N : M;
    }
    constexpr symb_type* place(symb_type* ptr) const noexcept {
        if (choice) {
            if constexpr (N != 0) {
                std::char_traits<symb_type>::copy(ptr, str_a, N);
            }
            return ptr + N;
        }
        if constexpr (M != 0) {
            std::char_traits<symb_type>::copy(ptr, (const K(&)[M + 1])str_b, M);
        }
        return ptr + M;
    }
};

template<StrExpr A, StrExprForType<typename A::symb_type> B>
constexpr expr_choice<A, B> e_choice(bool c, const A& a, const B& b) {
    return {a, b, c};
}

template<StrExpr A, typename T, size_t N = const_lit_for<typename A::symb_type, T>::Count>
constexpr expr_choice_one_lit<typename const_lit<T>::symb_type, A, N - 1, true> e_choice(bool c, const A& a, T&& str) {
    return {str, a, c};
}

template<StrExpr A, typename T, size_t N = const_lit_for<typename A::symb_type, T>::Count>
constexpr expr_choice_one_lit<typename const_lit<T>::symb_type, A, N - 1, false> e_choice(bool c, T&& str, const A& a) {
    return {str, a, c};
}

template<typename T, typename L, typename K = typename const_lit<T>::symb_type, typename P = typename const_lit<L>::symb_type,
    size_t N = const_lit<T>::Count, size_t M = const_lit_for<typename const_lit<T>::symb_type, L>::Count>
    requires is_equal_str_type_v<K, P>
constexpr expr_choice_two_lit<K, N -1, P, M - 1> e_choice(bool c, T&& str_a, L&& str_b) {
    return {str_a, str_b, c};
}

template<StrExpr A>
constexpr expr_if<A> e_if(bool c, const A& a) {
    return {a, c};
}

template<typename T, size_t N = const_lit<T>::Count>
constexpr auto e_if(bool c, T&& str) {
    using K = typename const_lit<T>::symb_type;
    const K empty[1] = {0};
    return expr_choice_two_lit<K, N - 1, K, 0>{str, empty, c};
}

template<typename K, StdStrSourceForType<K> T>
struct expr_stdstr {
    using symb_type = K;
    const T& t_;
 
    expr_stdstr(const T& t) : t_(t){}
 
    constexpr size_t length() const noexcept {
        return t_.size();
    }
    constexpr symb_type* place(symb_type* p) const noexcept {
        size_t s = t_.size();
        std::char_traits<K>::copy(p, (const K*)t_.data(), s);
        return p + s;
    }
};

template<typename K, StdStrSource T>
struct convert_to_strexpr<K, T> {
    using type = expr_stdstr<K, T>;
};
 
namespace str {
constexpr const size_t npos = static_cast<size_t>(-1); //NOLINT
} // namespace str
 
template<typename K>
std::char_traits<K> char_traits_selector(...);
 
template<typename K>
using ch_traits = decltype(char_traits_selector<K>(int(0)));
 
template<typename T>
concept FromIntNumber =
    is_one_of_type<std::remove_cv_t<T>, unsigned char, int, short, long, long long, unsigned, unsigned short, unsigned long, unsigned long long>::value;
 
template<typename T>
concept ToIntNumber = FromIntNumber<T> || is_one_of_type<T, int8_t>::value;
 
template<typename K, bool I, typename T>
struct need_sign { // NOLINT
    bool negate;
    std::make_unsigned_t<T> val;
    constexpr need_sign(T t) : negate(t < 0), val(t < 0 ? std::make_unsigned_t<T>{} - t : t) {}
    constexpr void after(K*& ptr) {
        if (negate)
            *--ptr = '-';
    }
};
 
template<typename K, typename T>
struct need_sign<K, false, T> {
    T val;
    constexpr need_sign(T t) : val(t){}
    constexpr void after(K*&) {}
};
 
template<typename K, typename T>
constexpr size_t fromInt(K* bufEnd, T val) {
    const char* twoDigit =
        "0001020304050607080910111213141516171819"
        "2021222324252627282930313233343536373839"
        "4041424344454647484950515253545556575859"
        "6061626364656667686970717273747576777879"
        "8081828384858687888990919293949596979899";
    if (val) {
        need_sign<K, std::is_signed_v<T>, T> store(val);
        K* itr = bufEnd;
        while (store.val >= 100) {
            const char* ptr = twoDigit + (store.val % 100) * 2;
            *--itr = static_cast<K>(ptr[1]);
            *--itr = static_cast<K>(ptr[0]);
            store.val /= 100;
        }
        if (store.val < 10) {
            *--itr = static_cast<K>('0' + store.val);
        } else {
            const char* ptr = twoDigit + store.val * 2;
            *--itr = static_cast<K>(ptr[1]);
            *--itr = static_cast<K>(ptr[0]);
        }
        store.after(itr);
        return size_t(bufEnd - itr);
    }
    bufEnd[-1] = '0';
    return 1;
}
 
template<typename K, typename T>
struct expr_num : expr_to_std_string<expr_num<K, T>> {
    using symb_type = K;
    using my_type = expr_num<K, T>;
 
    enum { bufSize = 24 };
    mutable K buf[bufSize];
    mutable T value;
 
    constexpr expr_num(T t) : value(t) {}
    constexpr expr_num(expr_num&& t) noexcept : value(t.value) {}
 
    constexpr size_t length() const noexcept {
        value = static_cast<T>(fromInt(buf + bufSize, value));
        return static_cast<size_t>(value);
    }
    constexpr K* place(K* ptr) const noexcept {
        size_t len = static_cast<size_t>(value);
        ch_traits<K>::copy(ptr, buf + bufSize - len, len);
        return ptr + len;
    }
};

template<typename K, FromIntNumber T>
struct convert_to_strexpr<K, T> {
    using type = expr_num<K, T>;
};

template<typename K, FromIntNumber T>
constexpr expr_num<K, T> e_num(T t) {
    return {t};
}
 
namespace f{
 
enum class int_align { none, left, right, center };
enum class int_plus_sign {none, plus, space};
enum class int_prefix {none, lcase, ucase};
 
enum fmt_kinds : unsigned {
    fmt_none = 0,
    fmt_align = 1,
    fmt_width = 2,
    fmt_fill = 4,
    fmt_sign = 8,
    fmt_upper = 16,
    fmt_prefix = 32,
    fmt_zero = 64,
};
 
template<typename A, typename B, unsigned Kind>
struct fmt_info {
    using a_t = A;
    using b_t = B;
    inline static constexpr unsigned kind = Kind;
};
 
struct fmt_default {
    inline static constexpr unsigned kind = fmt_none;
};
 
template<int_align A>
struct align_info{
    inline static constexpr unsigned kind = fmt_align;
};
 
template<size_t Width = 0>
struct width_info {
    inline static constexpr unsigned kind = fmt_width;
};
 
template<unsigned Fill = ' '>
struct fill_info {
    inline static constexpr unsigned kind = fmt_fill;
};
 
template<int_plus_sign S>
struct sign_info {
    inline static constexpr unsigned kind = fmt_sign;
};
 
struct upper_info {
    inline static constexpr unsigned kind = fmt_upper;
};
 
template<int_prefix>
struct prefix_info {
    inline static constexpr unsigned kind = fmt_prefix;
};
 
struct zero_info {
    inline static constexpr unsigned kind = fmt_zero;
};
 
template<typename T>
concept FmtParam = requires {
    {std::remove_cvref_t<T>::kind} -> std::same_as<const unsigned&>;
};
 
template<FmtParam A, FmtParam B>
requires((A::kind & B::kind) == 0)
constexpr auto operator | (const A&, const B&) {
    return fmt_info<A, B, A::kind | B::kind>{};
}
 
inline constexpr align_info<int_align::left> l;
inline constexpr align_info<int_align::right>  r;
inline constexpr align_info<int_align::center> c;
 
template<size_t W>
inline constexpr width_info<W> w;
 
template<unsigned F>
inline constexpr fill_info<F> f;
 
inline constexpr sign_info<int_plus_sign::plus> sp;
inline constexpr sign_info<int_plus_sign::space> ss;
inline constexpr upper_info u;
inline constexpr prefix_info<int_prefix::lcase> p;
inline constexpr prefix_info<int_prefix::ucase> P;
inline constexpr zero_info z;
 
inline constexpr width_info<unsigned(-1)> wp;
inline constexpr fmt_default df;
 
template<typename T>
struct extract_align : std::false_type {
    inline static constexpr int_align align = int_align::none;
};
 
template<int_align A>
struct extract_align<align_info<A>> : std::true_type {
    inline static constexpr int_align align = A;
};
 
template<typename A, typename B, unsigned U>
struct extract_align<fmt_info<A, B, U>> {
    inline static constexpr bool in_a = extract_align<A>::value, in_b = extract_align<B>::value, value = in_a | in_b;
    inline static constexpr int_align align = extract_align<std::conditional_t<in_a, A, std::conditional_t<in_b, B, align_info<int_align::none>>>>::align;
};
 
template<typename T>
struct extract_width : std::false_type {
    inline static constexpr size_t width = 0;
};
 
template<size_t W>
struct extract_width<width_info<W>> : std::true_type {
    inline static constexpr size_t width = W;
};
 
template<typename A, typename B, unsigned U>
struct extract_width<fmt_info<A, B, U>> {
    inline static constexpr bool in_a = extract_width<A>::value, in_b = extract_width<B>::value, value = in_a | in_b;
    inline static constexpr size_t width = extract_width<std::conditional_t<in_a, A, std::conditional_t<in_b, B, width_info<0>>>>::width;
};
 
template<typename T>
struct extract_fill : std::false_type {
    inline static constexpr unsigned fill = ' ';
};
 
template<unsigned F>
struct extract_fill<fill_info<F>> : std::true_type {
    inline static constexpr unsigned fill = F;
};
 
template<typename A, typename B, unsigned U>
struct extract_fill<fmt_info<A, B, U>> {
    inline static constexpr bool in_a = extract_fill<A>::value, in_b = extract_fill<B>::value, value = in_a | in_b;
    inline static constexpr unsigned fill = extract_fill<std::conditional_t<in_a, A, std::conditional_t<in_b, B, fill_info<' '>>>>::fill;
};
 
template<typename T>
struct extract_sign : std::false_type {
    inline static constexpr int_plus_sign sign = int_plus_sign::none;
};
 
template<int_plus_sign S>
struct extract_sign<sign_info<S>> : std::true_type {
    inline static constexpr int_plus_sign sign = S;
};
 
template<typename A, typename B, unsigned U>
struct extract_sign<fmt_info<A, B, U>> {
    inline static constexpr bool in_a = extract_sign<A>::value, in_b = extract_sign<B>::value, value = in_a | in_b;
    inline static constexpr int_plus_sign sign = extract_sign<std::conditional_t<in_a, A, std::conditional_t<in_b, B, sign_info<int_plus_sign::none>>>>::sign;
};
 
template<typename T>
struct extract_upper : std::false_type {};
 
template<>
struct extract_upper<upper_info> : std::true_type {};
 
template<typename A, typename B, unsigned U>
struct extract_upper<fmt_info<A, B, U>> {
    inline static constexpr bool in_a = extract_upper<A>::value, in_b = extract_upper<B>::value,
        value = extract_upper<std::conditional_t<in_a, A, std::conditional_t<in_b, B, std::false_type>>>::value;
};
 
template<typename T>
struct extract_prefix : std::false_type{
    inline static constexpr int_prefix prefix = int_prefix::none;
};
 
template<int_prefix P>
struct extract_prefix<prefix_info<P>> : std::true_type {
    inline static constexpr int_prefix prefix = P;
};
 
template<typename A, typename B, unsigned U>
struct extract_prefix<fmt_info<A, B, U>> {
    inline static constexpr bool in_a = extract_prefix<A>::value, in_b = extract_prefix<B>::value, value = in_a | in_b;
    inline static constexpr int_prefix prefix = extract_prefix<std::conditional_t<in_a, A, std::conditional_t<in_b, B, prefix_info<int_prefix::none>>>>::prefix;
};
 
template<typename T>
struct extract_zero : std::false_type{};
 
template<>
struct extract_zero<zero_info> : std::true_type {};
 
template<typename A, typename B, unsigned U>
struct extract_zero<fmt_info<A, B, U>> {
    inline static constexpr bool in_a = extract_zero<A>::value, in_b = extract_zero<B>::value,
        value = extract_zero<std::conditional_t<in_a, A, std::conditional_t<in_b, B, std::false_type>>>::value;
};
 
template<int_align Align, unsigned Width, unsigned Fill, int_plus_sign Sign, bool Upper, int_prefix Prefix, bool Zero>
struct fmt_params {
    inline static constexpr int_align align = Align;
    inline static constexpr unsigned width = Width;
    inline static constexpr unsigned fill = Fill;
    inline static constexpr int_plus_sign sign = Sign;
    inline static constexpr bool upper = Upper;
    inline static constexpr int_prefix prefix = Prefix;
    inline static constexpr bool zero = Zero;
};
 
template<FmtParam T>
using p_to_fmt_t = fmt_params<
    extract_align<T>::align,
    extract_width<T>::width,
    extract_fill<T>::fill,
    extract_sign<T>::sign,
    extract_upper<T>::value,
    extract_prefix<T>::prefix,
    extract_zero<T>::value>;
 
template<FmtParam T>
using to_fmt_t = p_to_fmt_t<std::remove_cvref_t<T>>;
 
template<typename T>
struct is_fmt_params : std::false_type{};
 
template<int_align Align, unsigned Width, unsigned Fill, int_plus_sign Sign, bool Upper, int_prefix Prefix, bool Zero>
struct is_fmt_params<fmt_params<Align, Width, Fill, Sign, Upper, Prefix, Zero>> : std::true_type{};
 
template<typename T>
concept FmtParamSet = is_fmt_params<T>::value;
 
struct fmt_end{};
 
template<f::FmtParam F>
constexpr auto operator|(const F& f, fmt_end) {
    return f;
}
 
template<char C = 0, char...Chars>
constexpr auto parse_fmt_symbol();
 
template<unsigned N, char C = 'Z', char...Chars>
constexpr auto parse_width() {
    if constexpr (C >= '0' && C <= '9') {
        return parse_width<N * 10 + C - '0', Chars...>();
    } else {
        return w<N> | parse_fmt_symbol<C, Chars...>();
    }
}
 
template<unsigned N, char C = 'Z', char...Chars>
constexpr auto parse_fill() {
    if constexpr (C >= '0' && C <= '9') {
        return parse_fill<N * 16 + C - '0', Chars...>();
    } else if constexpr (C >= 'a' && C <= 'f') {
        return parse_fill<N * 16 + C - 'a' + 10, Chars...>();
    } else if constexpr (C >= 'A' && C <= 'F') {
        return parse_fill<N * 16 + C - 'A' + 10, Chars...>();
    } else {
        return f<N> | parse_fmt_symbol<C, Chars...>();
    }
}
 
template<char C, char...Chars>
constexpr auto parse_fmt_symbol() {
    if constexpr (C == '0') {
        return z | parse_fmt_symbol<Chars...>();
    } else if constexpr (C == 'a') {
        return p | parse_fmt_symbol<Chars...>();
    } else if constexpr (C == 'A') {
        return P | parse_fmt_symbol<Chars...>();
    } else if constexpr (C == 'b') {
        return l | parse_fmt_symbol<Chars...>();
    } else if constexpr (C == 'c') {
        return c | parse_fmt_symbol<Chars...>();
    } else if constexpr (C == 'd') {
        return r | parse_fmt_symbol<Chars...>();
    } else if constexpr (C == 'e') {
        return sp | parse_fmt_symbol<Chars...>();
    } else if constexpr (C == 'f') {
        return ss | parse_fmt_symbol<Chars...>();
    } else if constexpr (C == 'E') {
        return u | parse_fmt_symbol<Chars...>();
    } else if constexpr (C == '\'') {
        return parse_fmt_symbol<Chars...>();
    } else if constexpr (C == 'F') {
        return parse_fill<0, Chars...>();
    } else if constexpr (C >= '1' && C <= '9') {
        return parse_width<C - '0', Chars...>();
    } else {
        return fmt_end{};
    }
}
 
template<unsigned R, typename T>
struct fmt_radix_info {};
 
template<unsigned N, char C = 0, char...Chars>
constexpr auto parse_radix() {
    if constexpr (C >='0' && C <= '9') {
        return parse_radix<N * 10 + C - '0', Chars...>();
    } else if constexpr (C == 0) {
        return fmt_radix_info<N, to_fmt_t<fmt_default>>{};
    } else {
        return fmt_radix_info<N, decltype(parse_fmt_symbol<C, Chars...>())>{};
    }
};
 
template<char C1, char C2, char C3, char...Chars>
constexpr auto skip_0x() {
    static_assert(C1 == '0' && C2 == 'x' && "Fmt symbols must begin with 0x");
    static_assert(C3 >= '1' && C3 <= '9' && "Radix must begin with 1-9");
    return parse_radix<C3 - '0', Chars...>();
}
 
} // namespace f
 
template<typename K, bool Ucase>
inline constexpr K digits_symbols[36] = {K('0'), K('1'), K('2'), K('3'), K('4'), K('5'), K('6'), K('7'), K('8'), K('9'),
    K(Ucase ? 'A' : 'a'), K(Ucase ? 'B' : 'b'), K(Ucase ? 'C' : 'c'), K(Ucase ? 'D' : 'd'), K(Ucase ? 'E' : 'e'),
    K(Ucase ? 'F' : 'f'), K(Ucase ? 'G' : 'g'), K(Ucase ? 'H' : 'h'), K(Ucase ? 'I' : 'i'), K(Ucase ? 'J' : 'j'),
    K(Ucase ? 'K' : 'k'), K(Ucase ? 'L' : 'l'), K(Ucase ? 'M' : 'm'), K(Ucase ? 'N' : 'n'), K(Ucase ? 'O' : 'o'),
    K(Ucase ? 'P' : 'p'), K(Ucase ? 'Q' : 'q'), K(Ucase ? 'R' : 'r'), K(Ucase ? 'S' : 's'), K(Ucase ? 'T' : 't'),
    K(Ucase ? 'U' : 'u'), K(Ucase ? 'V' : 'v'), K(Ucase ? 'W' : 'w'), K(Ucase ? 'X' : 'x'), K(Ucase ? 'Y' : 'y'),
    K(Ucase ? 'Z' : 'z'),
};
 
template<FromIntNumber T, unsigned Radix, f::FmtParamSet FP> requires (Radix > 1 && Radix <= 36)
struct expr_integer_src {
    T value_;
    unsigned width_{};
    constexpr expr_integer_src(T v) : value_(v){}
    constexpr expr_integer_src(T v, unsigned w) : value_(v), width_(w){}
 
    template<is_std_string_v S>
    operator S() const;
 
    template<typename S> requires std::is_constructible_v<S, empty_expr<typename S::symb_type>>
    operator S() const;
};
 
template<is_one_of_char_v K, FromIntNumber T, unsigned Radix, f::FmtParamSet FP>
requires (Radix > 1 && Radix <= 36)
struct expr_integer : expr_to_std_string<expr_integer<K, T, Radix, FP>> {
    using symb_type = K;
 
    enum { bufSize = 64 };
    mutable K buf[bufSize];
    mutable T value_;
    unsigned width_{};
 
    mutable bool negate_{};
 
    constexpr expr_integer(T t) : value_(t){}
    constexpr expr_integer(T t, unsigned w) : value_(t), width_(w){}
    constexpr expr_integer(const expr_integer_src<T, Radix, FP>& v) : value_(v.value_), width_(v.width_){}
 
    constexpr expr_integer(expr_integer&& t) noexcept : value_(t.value_), width_(t.width_){}
 
    constexpr size_t length() const noexcept {
        K* bufEnd = std::end(buf), *itr = bufEnd;
 
        if (value_) {
            need_sign<K, std::is_signed_v<T>, T> store(value_);
            while (store.val) {
                *--itr = digits_symbols<K, FP::upper>[store.val % Radix];
                store.val /= Radix;
            }
            if constexpr (std::is_signed_v<T>) {
                negate_ = store.negate;
            }
        } else {
            *--itr = digits_symbols<K, FP::upper>[0];
        }
        size_t len = bufEnd - itr;
        value_ = T(len);
        if constexpr (std::is_signed_v<T>) {
            if constexpr (FP::sign != f::int_plus_sign::none) {
                len++;
            } else {
                if (negate_) {
                    len++;
                }
            }
        }
        if constexpr (FP::prefix != f::int_prefix::none && (Radix == 2 || Radix == 8 || Radix == 16)) {
            len++;  // add 0
            if constexpr (Radix != 8) { // for octo just add 0,
                len++; // for other b or x
            }
        }
        if constexpr (FP::width == unsigned(-1)) {
            return std::max<size_t>(width_, len);
        } else {
            return std::max<size_t>(FP::width, len);
        }
    }
    constexpr K* place(K* ptr) const noexcept {
        size_t len = static_cast<size_t>(value_), all_len = len;
        if constexpr (std::is_signed_v<T>) {
            if constexpr (FP::sign != f::int_plus_sign::none) {
                all_len++;
            } else {
                if (negate_) {
                    all_len++;
                }
            }
        }
        if constexpr (FP::prefix != f::int_prefix::none && (Radix == 2 || Radix == 8 || Radix == 16)) {
            all_len++;  // add 0
            if constexpr (Radix != 8) { // for octo just add 0,
                all_len++; // for other b or x
            }
        }
        if constexpr (FP::zero) {
            if constexpr (std::is_signed_v<T>) {
                if (negate_) {
                    *ptr++ = K('-');
                } else {
                    if constexpr (FP::sign == f::int_plus_sign::plus) {
                        *ptr++ = K('+');
                    } else if constexpr (FP::sign == f::int_plus_sign::space) {
                        *ptr++ = K(' ');
                    }
                }
            }
            if constexpr (FP::prefix != f::int_prefix::none && (Radix == 2 || Radix == 8 || Radix == 16)) {
                *ptr++ = K('0');
                if constexpr (Radix == 2) {
                    *ptr++ = FP::prefix == f::int_prefix::lcase ? K('b') : K('B');
                } else if constexpr (Radix == 16) {
                    *ptr++ = FP::prefix == f::int_prefix::lcase ? K('x')  : K('X');
                }
            }
            size_t before = 0;
            if constexpr (FP::width == unsigned(-1)) {
                if (width_ > all_len) {
                    before = width_ - all_len;
                }
            } else {
                if (FP::width > all_len) {
                    before = FP::width - all_len;
                }
            }
            if (before) {
                ch_traits<K>::assign(ptr, before, K('0'));
                ptr += before;
            }
            ch_traits<K>::copy(ptr, std::end(buf) - len, len);
            ptr += len;
        } else {
            size_t before = 0, after = 0;
            if constexpr (FP::width == unsigned(-1)) {
                if (width_ > all_len) {
                    if constexpr (FP::align == f::int_align::left) {
                        after = width_ - all_len;
                    } else if constexpr (FP::align == f::int_align::center) {
                        before = (width_ - all_len) / 2;
                        after = width_ - all_len - before;
                    } else {
                        before = width_ - all_len;
                    }
                }
            } else {
                if (FP::width > all_len) {
                    if constexpr (FP::align == f::int_align::left) {
                        after = FP::width - all_len;
                    } else if constexpr (FP::align == f::int_align::center) {
                        before = (FP::width - all_len) / 2;
                        after = FP::width - all_len - before;
                    } else {
                        before = FP::width - all_len;
                    }
                }
            }
            if (before) {
                ch_traits<K>::assign(ptr, before, K(FP::fill));
                ptr += before;
            }
            if constexpr (std::is_signed_v<T>) {
                if (negate_) {
                    *ptr++ = K('-');
                } else {
                    if constexpr (FP::sign == f::int_plus_sign::plus) {
                        *ptr++ = K('+');
                    } else if constexpr (FP::sign == f::int_plus_sign::space) {
                        *ptr++ = K(' ');
                    }
                }
            }
            if constexpr (FP::prefix != f::int_prefix::none && (Radix == 2 || Radix == 8 || Radix == 16)) {
                *ptr++ = K('0');
                if constexpr (Radix == 2) {
                    *ptr++ = FP::prefix == f::int_prefix::lcase ? K('b') : K('B');
                } else if constexpr (Radix == 16) {
                    *ptr++ = FP::prefix == f::int_prefix::lcase ? K('x') : K('X');
                }
            }
            ch_traits<K>::copy(ptr, std::end(buf) - len, len);
            ptr += len;
 
            if (after) {
                ch_traits<K>::assign(ptr, after, K(FP::fill));
                ptr += after;
            }
        }
        return ptr;
    }
};
 
template<FromIntNumber T, unsigned Radix, f::FmtParamSet FP> requires (Radix > 1 && Radix <= 36)
template<is_std_string_v S>
expr_integer_src<T, Radix, FP>::operator S() const {
    using st = typename S::value_type;
    using Al = typename S::allocator_type;
    return to_std_string<st, Al>(expr_integer<st, T, Radix, FP>{value_, width_});
}
 
template<FromIntNumber T, unsigned Radix, f::FmtParamSet FP> requires (Radix > 1 && Radix <= 36)
template<typename S> requires std::is_constructible_v<S, empty_expr<typename S::symb_type>>
expr_integer_src<T, Radix, FP>::operator S() const {
    using st = typename S::symb_type;
    return S{expr_integer<st, T, Radix, FP>{value_, width_}};
}
 
template<typename K, FromIntNumber T, unsigned Radix, f::FmtParamSet FP>
struct convert_to_strexpr<K, expr_integer_src<T, Radix, FP>> {
    using type = expr_integer<K, T, Radix, FP>;
};
 
template<unsigned R, typename T, typename F>
struct flags_checker {
    using val_t = T;
    using flags_t = f::to_fmt_t<F>;
    inline static constexpr unsigned Radix = R;
};
 
template<typename T, bool ArgWidth>
concept good_int_flags =
    T::Radix > 1 && T::Radix <= 36
    // Должно быть задано только или выравнивание, или заполнение нулём.
    // Only either alignment or zero-padding must be specified.
    && (T::flags_t::align == f::int_align::none || !T::flags_t::zero)
    // Флаг вывода знака должен задаваться только для знаковых чисел
    // The sign output flag should only be set for signed numbers.
    && (std::is_signed_v<typename T::val_t> || T::flags_t::sign == f::int_plus_sign::none)
    // Неверное поле ширины
    // Invalid width field
    && (T::flags_t::width == unsigned(-1)) == ArgWidth
    // Префикс может быть только при основании 2, 8, 16
    // Prefix may by only for radix 2, 8, 16
    && (T::flags_t::prefix == f::int_prefix::none || T::Radix == 2 || T::Radix == 8 || T::Radix == 16);

template<unsigned R, auto fp = f::df, FromIntNumber T> requires good_int_flags<flags_checker<R, T,  decltype(fp)>, false>
constexpr auto e_int(T v) {
    using fmt_param = f::to_fmt_t<decltype(fp)>;
    return expr_integer_src<T, R, fmt_param>{v};
}

template<unsigned R, auto fp = f::df, FromIntNumber T> requires good_int_flags<flags_checker<R, T,  decltype(fp)>, true>
constexpr auto e_int(T v, unsigned w) {
    using fmt_param = f::to_fmt_t<decltype(fp)>;
    return expr_integer_src<T, R, fmt_param>{v, w};
}
 
template<typename T, unsigned R, typename F> requires good_int_flags<flags_checker<R, T, F>, false>
auto operator / (T v, const f::fmt_radix_info<R, F>&) {
    return expr_integer_src<T, R, f::to_fmt_t<F>>{v};
}
 
template<typename K>
struct expr_real : expr_to_std_string<expr_real<K>> {
    using symb_type = K;
    mutable u8s buf[40];
    mutable size_t l;
    double v;
    constexpr expr_real(double d) : v(d) {}
    constexpr expr_real(float d) : v(d) {}
 
    size_t length() const noexcept {
        auto [ptr, ec] = std::to_chars(buf, buf + std::size(buf), v);
        l = ec != std::errc{} ? 0 : ptr - buf;
        return l;
    }
    K* place(K* ptr) const noexcept {
        if constexpr (sizeof(K) == sizeof(buf[0])) {
            ch_traits<K>::copy(ptr, (K*)buf, l);
        } else {
            for (size_t i = 0; i < l; i++) {
                ptr[i] = buf[i];
            }
        }
        return ptr + l;
    }
};

template<typename K, std::floating_point T>
struct convert_to_strexpr<K, T> {
    using type = expr_real<K>;
};

template<typename K> requires is_one_of_char_v<K>
inline constexpr expr_real<K> e_num(double t) {
    return {t};
}
 
template<FromIntNumber Val, bool All, bool Ucase, bool Ox>
struct expr_hex_src {
    explicit constexpr expr_hex_src(Val v) : v_(v){}
    Val v_;
};
 
template<typename K, FromIntNumber Val, bool All, bool Ucase, bool Ox>
struct expr_hex : expr_to_std_string<expr_hex<K, Val, All, Ucase, Ox>> {
    using symb_type = K;
    mutable need_sign<K, std::is_signed_v<Val>, Val> v_;
    mutable K buf_[sizeof(Val) * 2]{};
 
    explicit constexpr expr_hex(Val v) : v_(v){}
    constexpr expr_hex(const expr_hex_src<Val, All, Ucase, Ox>& v) : v_(v.v_){}
 
    constexpr size_t length() const noexcept {
        K *ptr = buf_ + std::size(buf_);
        size_t l = 0;
        for (;;) {
            *--ptr = digits_symbols<K, Ucase>[v_.val & 0xF];
            v_.val >>= 4;
            l++;
            if (v_.val) {
                *--ptr = digits_symbols<K, Ucase>[v_.val & 0xF];
                v_.val >>= 4;
                l++;
            }
            if (!v_.val) {
                if constexpr (All) {
                    if (size_t need = sizeof(Val) * 2 - l) {
                        ch_traits<K>::assign(buf_, need, K('0'));
                    }
                    l = sizeof(Val) * 2;
                }
                break;
            }
        }
        v_.val = l;
        if constexpr (std::is_signed_v<Val>) {
            return l + (Ox ? 2 : 0) + (v_.negate ? 1 : 0);
        }
        return l + (Ox ? 2 : 0);
    }
    constexpr K* place(K* ptr) const noexcept {
        if constexpr (std::is_signed_v<Val>) {
            if (v_.negate) {
                *ptr++ = K('-');
            }
        }
        if constexpr (Ox) {
            *ptr++ = K('0');
            *ptr++ = K('x');
        }
        if constexpr (All) {
            ch_traits<K>::copy(ptr, buf_, sizeof(Val) * 2);
            return ptr + sizeof(Val) * 2;
        } else {
            ch_traits<K>::copy(ptr, buf_ + std::size(buf_) - v_.val, v_.val);
            return ptr + v_.val;
        }
    }
};

enum HexFlags : unsigned {
    Short = 1,  
    No0x = 2,   //< without 0x prefix
    Lcase = 4,  //< Use lower case
};

template<unsigned Flags = 0, FromIntNumber T>
constexpr auto e_hex(T v) {
    return expr_hex_src<T, (Flags & HexFlags::Short) == 0, (Flags & HexFlags::Lcase) == 0, (Flags & HexFlags::No0x) == 0>{v};
}
 
template<char c = 0, char...Chars>
constexpr unsigned parse_f16_flags() {
    if constexpr (c == '1') {
        return HexFlags::Short | parse_f16_flags<Chars...>();
    } else if constexpr (c == '2') {
        return HexFlags::Lcase | parse_f16_flags<Chars...>();
    } else if constexpr (c == '3') {
        return HexFlags::No0x | parse_f16_flags<Chars...>();
    } else {
        return 0;
    }
}
 
template<unsigned N>
struct f16flags{};
 
template<FromIntNumber T, unsigned Flags>
constexpr auto operator/(T v, const f16flags<Flags>&) {
    return expr_hex_src<T, (Flags & HexFlags::Short) == 0, (Flags & HexFlags::Lcase) == 0, (Flags & HexFlags::No0x) == 0>{v};
}
 
inline namespace literals {
template<char...Chars>
constexpr auto operator""_f16() {
    return f16flags<parse_f16_flags<Chars...>()>{};
}
} // namespace literals

template<typename K, typename Val, bool All, bool Ucase, bool Ox>
struct convert_to_strexpr<K, expr_hex_src<Val, All, Ucase, Ox>> {
    using type = expr_hex<K, Val, All, Ucase, Ox>;
};
 
template<typename K>
struct expr_pointer : expr_hex<K, uintptr_t, true, true, true> {
    constexpr expr_pointer(const void* ptr) : expr_hex<K, uintptr_t, true, true, true>((uintptr_t)ptr){}
};

template<typename K, typename T>
struct convert_to_strexpr<K, const T*> {
    using type = expr_pointer<K>;
};
 
template<typename K, StrExprForType<K> A, bool Left>
struct expr_fill : expr_to_std_string<expr_fill<K, A, Left>>{
    using symb_type = K;
    K symbol_;
    size_t width_;
    const A& a_;
    mutable size_t alen_{};
    constexpr expr_fill(K symbol, size_t width, const A& a) : symbol_(symbol), width_(width), a_(a){}
 
    constexpr size_t length() const noexcept {
        alen_ = a_.length();
        return std::max(alen_, width_);
    }
    constexpr K* place(K* ptr) const noexcept {
        if (alen_ >= width_) {
            return (K*)a_.place((typename A::symb_type*)ptr);
        }
        size_t w = width_ - alen_;
        if constexpr (Left) {
            ch_traits<K>::assign(ptr, w, symbol_);
            ptr += w;
            return (K*)a_.place((typename A::symb_type*)ptr);
        } else {
            ptr = (K*)a_.place((typename A::symb_type*)ptr);
            ch_traits<K>::assign(ptr, w, symbol_);
            return ptr + w;
        }
    }
};

template<StrExpr A, typename K = typename A::symb_type>
expr_fill<K, A, true> e_fill_left(const A& a, size_t width, K symbol = K(' ')) {
    return {symbol, width, a};
}

template<StrExpr A, typename K = typename A::symb_type>
expr_fill<K, A, false> e_fill_right(const A& a, size_t width, K symbol = K(' ')) {
    return {symbol, width, a};
}
 
/*
* Для создания строковых конкатенаций с векторами и списками, сджойненными константным разделителем
* K - тип символов строки
* T - тип контейнера строк (vector, list)
* I - длина разделителя в символах
* tail - добавлять разделитель после последнего элемента контейнера.
*        Если контейнер пустой, разделитель в любом случае не добавляется
* skip_empty - пропускать пустые строки без добавления разделителя
* To create string concatenations with vectors and lists joined by a constant delimiter
* K is the symbols
* T - type of string container (vector, list)
* I - length of separator in characters
* tail - add a separator after the last element of the container.
* If the container is empty, the separator is not added anyway
* skip_empty - skip empty lines without adding a separator
*/
template<typename K, typename T, size_t I, bool tail, bool skip_empty>
struct expr_join : expr_to_std_string<expr_join<K, T, I, tail, skip_empty>> {
    using symb_type = K;
    using my_type = expr_join<K, T, I, tail, skip_empty>;
 
    const T& s;
    const K* delim;
    constexpr expr_join(const T& _s, const K* _delim) : s(_s), delim(_delim){}
 
    constexpr size_t length() const noexcept {
        size_t l = 0;
        for (const auto& t: s) {
            size_t len = t.length();
            if (len > 0 || !skip_empty) {
                if (I > 0 && l > 0) {
                    l += I;
                }
                l += len;
            }
        }
        return l + (tail && I > 0 && (l > 0 || (!skip_empty && std::size(s) > 0))? I : 0);
    }
    constexpr K* place(K* ptr) const noexcept {
        if (s.empty()) {
            return ptr;
        }
        K* write = ptr;
        for (const auto& t: s) {
            size_t copyLen = t.length();
            if ((copyLen > 0 || !skip_empty) && I > 0 && write != ptr) {
                ch_traits<K>::copy(write, delim, I);
                write += I;
            }
            ch_traits<K>::copy(write, t.data(), copyLen);
            write += copyLen;
        }
        if (tail && I > 0 && (write != ptr || (!skip_empty && std::size(s) > 0))) {
            ch_traits<K>::copy(write, delim, I);
            write += I;
        }
        return write;
    }
};

template<bool tail = false, bool skip_empty = false, typename L, typename K = typename const_lit<L>::symb_type, size_t I = const_lit<L>::Count, typename T>
inline constexpr auto e_join(const T& s, L&& d) {
    return expr_join<K, T, I - 1, tail, skip_empty>{s, d};
}
 
template<size_t N>
concept is_const_pattern = N > 1 && N <= 17;
 
template<typename K, size_t I>
struct _ascii_mask { // NOLINT
    constexpr static const size_t value = size_t(K(~0x7F)) << ((I - 1) * sizeof(K) * 8) | _ascii_mask<K, I - 1>::value;
};
 
template<typename K>
struct _ascii_mask<K, 0> {
    constexpr static const size_t value = 0;
};
 
template<typename K>
struct ascii_mask { // NOLINT
    using uns = std::make_unsigned_t<K>;
    constexpr static const size_t WIDTH = sizeof(size_t) / sizeof(uns);
    constexpr static const size_t VALUE = _ascii_mask<uns, WIDTH>::value;
};
 
template<typename K>
constexpr inline bool isAsciiUpper(K k) {
    return k >= 'A' && k <= 'Z';
}
 
template<typename K>
constexpr inline bool isAsciiLower(K k) {
    return k >= 'a' && k <= 'z';
}
 
template<typename K>
constexpr inline K makeAsciiLower(K k) {
    return isAsciiUpper(k) ? k | 0x20 : k;
}
 
template<typename K>
constexpr inline K makeAsciiUpper(K k) {
    return isAsciiLower(k) ? k & ~0x20 : k;
}
 
enum TrimSides { TrimLeft = 1, TrimRight = 2, TrimAll = 3 };
template<TrimSides S, typename K, size_t N, bool withSpaces = false>
struct trim_operator;
 
template<size_t I>
struct digits_selector {
    using wider_type = uint16_t;
};
 
template<>
struct digits_selector<2> {
    using wider_type = uint32_t;
};
 
template<>
struct digits_selector<4> {
    using wider_type = uint64_t;
};

enum class IntConvertResult : char {
    Success,            
    BadSymbolAtTail,    
    Overflow,           
    NotNumber           
};
 
template<bool CanNegate, bool CheckOverflow, typename T>
struct result_type_selector { // NOLINT
    using type = T;
};
 
template<typename T>
struct result_type_selector<true, false, T> {
    using type = std::make_unsigned_t<T>;
};
 
template<unsigned Base>
constexpr unsigned digit_width() {
    if (Base <=2) {
        return 1;
    }
    if (Base <= 4) {
        return 2;
    }
    if (Base <= 8) {
        return 3;
    }
    if (Base <= 16) {
        return 4;
    }
    if (Base <= 32) {
        return 5;
    }
    return 6;
}
 
template<typename T, unsigned Base>
constexpr unsigned max_overflow_digits = (sizeof(T) * CHAR_BIT) / digit_width<Base>();
 
template<typename T>
struct convert_result {
    T value;
    IntConvertResult ec;
    size_t read;
};
 
struct int_convert { // NOLINT
    inline static constexpr uint8_t NUMBERS[] = {
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0,   1,   2,   3,
        4,   5,   6,   7,   8,   9,   255, 255, 255, 255, 255, 255, 255, 10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,
        23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  255, 255, 255, 255, 255, 255, 10,  11,  12,  13,  14,  15,  16,
        17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  255, 255, 255, 255, 255, 255, 255,
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255};
 
    template<typename K, unsigned Base>
    static constexpr std::make_unsigned_t<K> toDigit(K s) {
        auto us = static_cast<std::make_unsigned_t<K>>(s);
        if constexpr (Base <= 10) {
            return us - '0';
        } else {
            if constexpr (sizeof(K) == 1) {
                return NUMBERS[us];
            } else {
                return us < 256 ? NUMBERS[us] : us;
            }
        }
    }
 
    template<typename K, ToIntNumber T, unsigned Base, bool CheckOverflow>
        requires(Base != 0)
    static constexpr convert_result<T> parse(const K* start, const K* current, const K* end, bool negate) {
        using u_type = std::make_unsigned_t<T>;
        #ifndef HAS_BUILTIN_OVERFLOW
        u_type  maxMult = 0, maxAdd = 0;
        if constexpr (CheckOverflow) {
            maxMult = std::numeric_limits<u_type>::max() / Base;
            maxAdd = std::numeric_limits<u_type>::max() % Base;
        }
        #endif
        u_type number = 0;
        unsigned maxDigits = max_overflow_digits<u_type, Base>;
        IntConvertResult error = IntConvertResult::NotNumber;
        const K* from = current;
 
        bool no_need_check_o_f = !CheckOverflow || end - current <= maxDigits;
 
        if (no_need_check_o_f) {
            for (;;) {
                const u_type digit = toDigit<K, Base>(*current);
                if (digit >= Base) {
                    break;
                }
                number = number * Base + digit;
                if (++current == end) {
                    error = IntConvertResult::Success;
                    break;
                }
            }
        } else {
            for (;maxDigits; maxDigits--) {
                const u_type digit = toDigit<K, Base>(*current);
                if (digit >= Base) {
                    break;
                }
                number = number * Base + digit;
                ++current;
            }
            if (!maxDigits) {
                // Прошли все цифры, дальше надо с проверкой на overflow
                // All numbers have passed, then we need to check for overflow
                for (;;) {
                    const u_type digit = toDigit<K, Base>(*current);
                    if (digit >= Base) {
                        break;
                    }
                    #ifdef HAS_BUILTIN_OVERFLOW
                    if (__builtin_mul_overflow(number, Base, &number) ||
                        __builtin_add_overflow(number, digit, &number)) {
                    #else
                    if (number < maxMult || (number == maxMult && number < maxAdd)) {
                        number = number * Base + digit;
                    } else {
                    #endif
                        error = IntConvertResult::Overflow;
                        while(++current < end) {
                            if (toDigit<K, Base>(*current) >= Base) {
                                break;
                            }
                        }
                        break;
                    }
                    if (++current == end) {
                        error = IntConvertResult::Success;
                        break;
                    }
                }
            }
        }
        T result;
        if constexpr (std::is_signed_v<T>) {
            result = negate ? 0 - number : number;
            if constexpr (CheckOverflow) {
                if (error != IntConvertResult::Overflow) {
                    if (number > (u_type)std::numeric_limits<T>::max() + (negate ? 1 : 0)) {
                        error = IntConvertResult::Overflow;
                    }
                }
            }
        } else {
            result = number;
        }
        if (error == IntConvertResult::NotNumber && current > from) {
            error = IntConvertResult::BadSymbolAtTail;
        }
        return {result, error, size_t(current - start)};
    }
public:
    // Если Base = 0 - то пытается определить основание по префиксу 0[xX] как 16, 0 как 8, иначе 10
    // Если Base = -1 - то пытается определить основание по префиксу 0[xX] как 16, 0[bB] как 2, 0[oO] или 0 как 8, иначе 10
    // If Base = 0, then it tries to determine the base by the prefix 0[xX] as 16, 0 as 8, otherwise 10
    // If Base = -1 - then tries to determine the base by the prefix 0[xX] as 16, 0[bB] as 2, 0[oO] or 0 as 8, otherwise 10
    template<typename K, ToIntNumber T, unsigned Base = 0, bool CheckOverflow = true, bool SkipWs = true, bool AllowSign = true>
        requires(Base == unsigned(-1) || (Base < 37 && Base != 1))
    static constexpr convert_result<T> to_integer(const K* start, size_t len) noexcept {
        const K *ptr = start, *end = ptr + len;
        bool negate = false;
        if constexpr (SkipWs) {
            while (ptr < end && std::make_unsigned_t<K>(*ptr) <= ' ')
                ptr++;
        }
        if (ptr != end) {
            if constexpr (std::is_signed_v<T>) {
                if constexpr (AllowSign) {
                    // Может быть число, +число или -число
                    // Can be a number, +number or -number
                    if (*ptr == '+') {
                        ptr++;
                    } else if (*ptr == '-') {
                        negate = true;
                        ptr++;
                    }
                } else {
                    // Может быть число или -число
                    // Can be a number or -number
                    if (*ptr == '-') {
                        negate = true;
                        ptr++;
                    }
                }
            } else if constexpr (AllowSign) {
                // Может быть число или +число
                // Can be a number or +number
                if (*ptr == '+') {
                    ptr++;
                }
            }
        }
        if (ptr != end) {
            if constexpr (Base == 0 || Base == unsigned(-1)) {
                if (*ptr == '0') {
                    ptr++;
                    if (ptr != end) {
                        if (*ptr == 'x' || *ptr == 'X') {
                            return parse<K, T, 16, CheckOverflow>(start, ++ptr, end, negate);
                        }
                        if constexpr (Base == unsigned(-1)) {
                            if (*ptr == 'b' || *ptr == 'B') {
                                return parse<K, T, 2, CheckOverflow>(start, ++ptr, end, negate);
                            }
                            if (*ptr == 'o' || *ptr == 'O') {
                                return parse<K, T, 8, CheckOverflow>(start, ++ptr, end, negate);
                            }
                        }
                        return parse<K, T, 8, CheckOverflow>(start, --ptr, end, negate);
                    }
                    return {0, IntConvertResult::Success, size_t(ptr - start)};
                }
                return parse<K, T, 10, CheckOverflow>(start, ptr, end, negate);
            } else
                return parse<K, T, Base, CheckOverflow>(start, ptr, end, negate);
        }
        return {0, IntConvertResult::NotNumber, size_t(ptr - start)};
    }
};
 
template<typename K, typename Impl>
class null_terminated {
public:
    constexpr const K* c_str() const { return static_cast<const Impl*>(this)->symbols(); }
};
 
template<typename K, typename Impl, bool Mutable> class buffer_pointers;

template<typename K, typename Impl>
class buffer_pointers<K, Impl, false> {
    constexpr const Impl& d() const { return *static_cast<const Impl*>(this); }
public:
    constexpr const K* data() const  { return d().symbols(); }
    constexpr const K* begin() const { return d().symbols(); }
    constexpr const K* end() const   { return d().symbols() + d().length(); }
    constexpr const K* cbegin() const { return d().symbols(); }
    constexpr const K* cend() const   { return d().symbols() + d().length(); }
};
 
template<typename K, typename Impl>
class buffer_pointers<K, Impl, true> : public buffer_pointers<K, Impl, false> {
    constexpr Impl& d() { return *static_cast<Impl*>(this); }
    using base = buffer_pointers<K, Impl, false>;
public:
    constexpr const K* data() const  { return base::data(); }
    constexpr const K* begin() const { return base::begin(); }
    constexpr const K* end() const   { return base::end(); }
    constexpr const K* cbegin() const { return base::cbegin(); }
    constexpr const K* cend() const   { return base::cend(); }
    constexpr K* data()  { return d().str(); }
    constexpr K* begin() { return d().str(); }
    constexpr K* end()   { return d().str() + d().length(); }
};

template<typename K, typename StrSrc>
class SplitterBase {
    using str_t = StrSrc;
    str_t text_;
    str_t delim_;
 
public:
    constexpr SplitterBase(str_t text, str_t delim) : text_(text), delim_(delim) {}
    constexpr bool is_done() const {
        return text_.length() == str::npos;
    }

    constexpr str_t next() {
        if (!text_.length()) {
            auto ret = text_;
            text_.str++;
            text_.len--;
            return ret;
        } else if (text_.length() == str::npos) {
            return {nullptr, 0};
        }
        size_t pos = text_.find(delim_), next = 0;
        if (pos == str::npos) {
            pos = text_.length();
            next = pos + 1;
        } else {
            next = pos + delim_.length();
        }
        str_t result{text_.str, pos};
        text_.str += next;
        text_.len -= next;
        return result;
    }
};
 
struct from_begin {
    size_t idx_;
};
struct from_end {
    size_t idx_;
};
inline constexpr from_end to_end{0};
 
template<typename T, typename K>
concept is_slice_find = requires (const T& t) {
    requires is_equal_str_type_v<K, symb_type_from_src_t<decltype(t.pattern_)>>;
    { T::to_end_of_pattern }->std::same_as<const bool&>;
    { T::offset_from_found }->std::same_as<const bool&>;
    { T::find_reverse }->std::same_as<const bool&>;
    { T::all_at_fail }->std::same_as<const bool&>;
    { t.offset_ } -> std::convertible_to<size_t>;
    { t.skip_ } -> std::convertible_to<size_t>;
    { t.find(t.pattern_, size_t(0)) } -> std::convertible_to<size_t>;
};
 
template<typename T>
using slice_find_func = size_t(*)(T, T, size_t);
 
template<typename Pattern, bool ToEndOfPattern, bool OffsetFromFound, bool AllAtFail, bool FindReverse, slice_find_func<Pattern> F>
struct slice_find {
    inline static constexpr const bool to_end_of_pattern = ToEndOfPattern;
    inline static constexpr const bool offset_from_found = OffsetFromFound;
    inline static constexpr const bool find_reverse = FindReverse;
    inline static constexpr const bool all_at_fail = AllAtFail;
 
    template<StrSource S>
    constexpr slice_find(S&& pattern, size_t offset = 0, size_t skip = 0) {
        pattern_ =  std::forward<S>(pattern);
        offset_ = offset;
        skip_ = skip;
    }
 
    constexpr size_t find(Pattern where, size_t offset) const {
        return F(where, pattern_, offset);
    }
    Pattern pattern_;
    size_t offset_;
    size_t skip_;
};
 
template<typename T, typename K>
concept first_index_in_str = std::is_same_v<T, from_end> || std::is_convertible_v<T, size_t> || is_slice_find<T, K>;
 
template<typename T, typename K>
concept last_index_in_str = first_index_in_str<T, K> || std::is_same_v<T, from_begin>;

template<typename K, typename StrRef, typename Impl, bool Mutable>
class str_src_algs : public buffer_pointers<K, Impl, Mutable> {
    constexpr const Impl& d() const noexcept {
        return *static_cast<const Impl*>(this);
    }
    constexpr size_t _len() const noexcept {
        return d().length();
    }
    constexpr const K* _str() const noexcept {
        return d().symbols();
    }
    constexpr bool _is_empty() const noexcept {
        return d().is_empty();
    }
 
public:
    using symb_type = K;
    using str_piece = StrRef;
    using traits = ch_traits<K>;
    using uns_type = std::make_unsigned_t<K>;
    using my_type = Impl;
    using base = str_src_algs<K, StrRef, Impl, Mutable>;
    str_src_algs() = default;

    constexpr K* place(K* ptr) const noexcept {
        size_t myLen = _len();
        traits::copy(ptr, _str(), myLen);
        return ptr + myLen;
    }

    void copy_to(K* buffer, size_t bufSize) {
        size_t tlen = std::min(_len(), bufSize - 1);
        traits::copy(buffer, _str(), tlen);
        buffer[tlen] = 0;
    }

    constexpr size_t size() const {
        return _len();
    }

    template<typename D = K> requires is_equal_str_type_v<K, D>
    constexpr std::basic_string_view<D> to_sv() const noexcept {
        return {(const D*)_str(), _len()};
    }

    template<typename D, typename Traits> requires is_equal_str_type_v<K, D>
    constexpr operator std::basic_string_view<D, Traits>() const {
        return {(const D*)_str(), _len()};
    }

    template<typename D = K, typename Traits = std::char_traits<D>, typename Allocator = std::allocator<D>> requires is_equal_str_type_v<K, D>
    constexpr std::basic_string<D, Traits, Allocator> to_string() const {
        return {(const D*)_str(), _len()};
    }

    template<typename D, typename Traits, typename Allocator> requires is_equal_str_type_v<K, D>
    constexpr operator std::basic_string<D, Traits, Allocator>() const {
        return {(const D*)_str(), _len()};
    }

    constexpr operator str_piece() const noexcept {
        return str_piece{_str(), _len()};
    }

    constexpr str_piece to_str() const noexcept {
        return {_str(), _len()};
    }

    [[deprecated("Use 'slice' or [start, end] in C++23")]]
    constexpr str_piece operator()(ptrdiff_t from, ptrdiff_t len = 0) const noexcept {
        size_t myLen = _len(), idxStart = from >= 0 ? from : (ptrdiff_t)myLen > -from ? myLen + from : 0,
            idxEnd = len > 0 ? idxStart + len : (ptrdiff_t)myLen > -len ? myLen + len : 0;
        if (idxEnd > myLen)
            idxEnd = myLen;
        if (idxStart > idxEnd)
            idxStart = idxEnd;
        return str_piece{_str() + idxStart, idxEnd - idxStart};
    }

    template<first_index_in_str<K> S, last_index_in_str<K> E>
    constexpr str_piece slice(S start, E end) const noexcept {
        size_t idxStart, idxEnd, len = _len();
        if constexpr (is_slice_find<S, K>) {
            size_t offset = std::min(S::find_reverse ? len - start.offset_ : start.offset_, len), skip = start.skip_;
            for (;;) {
                size_t find = start.find(d(), offset);
                if (find == str::npos) {
                    if constexpr (S::all_at_fail) {
                        idxStart = 0;
                    } else {
                        idxStart = len;
                    }
                    break;
                }
                if (!skip--) {
                    if constexpr (S::to_end_of_pattern) {
                        idxStart = find + start.pattern_.length();
                    } else {
                        idxStart = find;
                    }
                    break;
                }
                offset = find;
                if constexpr (!S::find_reverse) {
                    offset += start.pattern_.length();
                }
            }
        } else if constexpr (std::is_same_v<S, from_end>) {
            idxStart = start.idx_ >= len ? 0 : len - start.idx_;
        } else {
            idxStart = std::min(size_t(start), len);
        }
 
        if constexpr (is_slice_find<E, K>) {
            size_t offset = std::min(E::offset_from_found ? idxStart + end.offset_ : E::find_reverse ? len - end.offset_ : end.offset_, len), skip = end.skip_;
            for (;;) {
                size_t find = end.find(d(), offset);
                if (find == str::npos) {
                    if constexpr (E::all_at_fail) {
                        idxEnd = len;
                    } else {
                        idxEnd = idxStart;
                    }
                    break;
                }
                if (!skip--) {
                    if constexpr (E::to_end_of_pattern) {
                        idxEnd = find + end.pattern_.length();
                    } else {
                        idxEnd = find;
                    }
                    break;
                }
                offset = find;
                if constexpr (!E::find_reverse) {
                    offset += end.pattern_.length();
                }
            }
        } else if constexpr (std::is_same_v<E, from_begin>) {
            idxEnd = std::max(idxStart, std::min(end.idx_, len));
        } else if constexpr (std::is_same_v<E, from_end>) {
            idxEnd = std::max(idxStart, end.idx_ >= len ? 0 : len - end.idx_);
        } else {
            size_t e = end;
            idxEnd = len - idxStart <= e ? len : idxStart + e;
        }
 
        return str_piece{_str() + idxStart, idxEnd - idxStart};
    }
 
#if defined(__cpp_multidimensional_subscript) && __cpp_multidimensional_subscript >= 202211L
    template<first_index_in_str<K> S, last_index_in_str<K> E>
    constexpr str_piece operator[](S start, E end) const noexcept {
        return slice(start, end);
    }
#endif
    template<typename E> requires std::is_convertible_v<E, size_t> || is_slice_find<E, K>
    constexpr str_piece prefix(E count) const noexcept {
        return slice(0, count);
    }

    template<typename E> requires std::is_convertible_v<E, size_t> || is_slice_find<E, K>
    constexpr str_piece tail(E count) const noexcept {
        return slice(count, to_end);
    }

    template<typename E> requires std::is_convertible_v<E, size_t> || is_slice_find<E, K>
    constexpr str_piece suffix(E count) const noexcept {
        if constexpr (std::is_convertible_v<E, size_t>) {
            return slice(from_end(static_cast<size_t>(count)), to_end);
        } else {
            return slice(count, to_end);
        }
    }

    [[deprecated("Use 'slice' or [start, len] in C++23")]]
    constexpr str_piece mid(size_t from, size_t len = -1) const noexcept {
        size_t myLen = _len(), idxStart = from, idxEnd = from > std::numeric_limits<size_t>::max() - len ? myLen : from + len;
        if (idxEnd > myLen)
            idxEnd = myLen;
        if (idxStart > idxEnd)
            idxStart = idxEnd;
        return str_piece{_str() + idxStart, idxEnd - idxStart};
    }

    constexpr str_piece from_to(size_t from, size_t to) const noexcept {
        return str_piece{_str() + from, to - from};
    }

    [[deprecated("Use 'slice(0, begin_or_all(pattern, offset))' or '[0, begin_or_all(pattern, offset)]' in C++23, or 'slice(0, \"pattern\"_boa))'")]]
    constexpr str_piece until(str_piece pattern, size_t offset = 0) const noexcept {
        return slice(0, find_or_all(pattern, offset));
    }

    constexpr bool operator!() const noexcept {
        return _is_empty();
    }

    constexpr K at(ptrdiff_t idx) const {
        return _str()[idx >= 0 ? idx : _len() + idx];
    }
    // Сравнение строк
    // String comparison
    constexpr int compare(const K* text, size_t len) const {
        size_t myLen = _len();
        int cmp = traits::compare(_str(), text, std::min(myLen, len));
        return cmp == 0 ? (myLen > len ? 1 : myLen == len ? 0 : -1) : cmp;
    }
    constexpr int compare(str_piece o) const {
        return compare(o.symbols(), o.length());
    }

    constexpr int strcmp(const K* text) const {
        size_t myLen = _len(), idx = 0;
        const K* ptr = _str();
        for (; idx < myLen; idx++) {
            uns_type s1 = (uns_type)text[idx];
            if (!s1) {
                return 1;
            }
            uns_type s2 = (uns_type)ptr[idx];
            if (s1 < s2) {
                return 1;
            } else if (s1 > s2) {
                return -1;
            }
        }
        return text[idx] == 0 ? 0 : -1;
    }
 
    constexpr bool equal(const K* text, size_t len) const noexcept {
        return len == _len() && traits::compare(_str(), text, len) == 0;
    }
    constexpr bool equal(str_piece other) const noexcept {
        return equal(other.symbols(), other.length());
    }

    constexpr bool operator==(const base& other) const noexcept {
        return equal(other._str(), other._len());
    }

    constexpr auto operator<=>(const base& other) const noexcept {
        return compare(other._str(), other._len()) <=> 0;
    }

    template<typename T, size_t N = const_lit_for<K, T>::Count>
    constexpr bool operator==(T&& other) const noexcept {
        return N - 1 == _len() && traits::compare(_str(), (const K*)other, N - 1) == 0;
    }

    template<typename T, size_t N = const_lit_for<K, T>::Count>
    constexpr auto operator<=>(T&& other) const noexcept {
        size_t myLen = _len();
        int cmp = traits::compare(_str(), (const K*)other, std::min(myLen, N - 1));
        int res = cmp == 0 ? (myLen > N - 1 ? 1 : myLen == N - 1 ? 0 : -1) : cmp;
        return res <=> 0;
    }
 
    // Сравнение ascii строк без учёта регистра
    // Compare ascii strings without taking into account case
    constexpr int compare_ia(const K* text, size_t len) const noexcept { // NOLINT
        if (!len)
            return _is_empty() ? 0 : 1;
        size_t myLen = _len(), checkLen = std::min(myLen, len);
        const uns_type *ptr1 = reinterpret_cast<const uns_type*>(_str()), *ptr2 = reinterpret_cast<const uns_type*>(text);
        while (checkLen--) {
            uns_type s1 = *ptr1++, s2 = *ptr2++;
            if (s1 == s2)
                continue;
            s1 = makeAsciiLower(s1);
            s2 = makeAsciiLower(s2);
            if (s1 > s2)
                return 1;
            else if (s1 < s2)
                return -1;
        }
        return myLen == len ? 0 : myLen > len ? 1 : -1;
    }
    constexpr int compare_ia(str_piece text) const noexcept { // NOLINT
        return compare_ia(text.symbols(), text.length());
    }

    constexpr bool equal_ia(str_piece text) const noexcept { // NOLINT
        size_t len = _len();
        if (len != text.length())
            return false;
        const uns_type *ptr1 = reinterpret_cast<const uns_type*>(_str()), *ptr2 = reinterpret_cast<const uns_type*>(text.symbols());
        while (len--) {
            uns_type s1 = *ptr1++, s2 = *ptr2++;
            if (s1 == s2)
                continue;
            if (isAsciiUpper(s1)) {
                if (s1 == (s2 & ~0x20)) {
                    continue;
                }
            } else if (isAsciiLower(s1) && s1 == (s2 | 0x20)) {
                continue;
            }
            return false;
        }
        return true;
    }

    constexpr bool less_ia(str_piece text) const noexcept { // NOLINT
        return compare_ia(text.symbols(), text.length()) < 0;
    }
 
    constexpr size_t find(const K* pattern, size_t lenPattern, size_t offset) const noexcept {
        size_t lenText = _len();
        // Образец, не вмещающийся в строку и пустой образец не находим
        // We don't look for an empty string or a string longer than the text.
        if (!lenPattern || offset >= lenText || offset + lenPattern > lenText)
            return str::npos;
        lenPattern--;
        const K *text = _str(), *last = text + lenText - lenPattern, first = pattern[0];
        pattern++;
        for (const K* fnd = text + offset;; ++fnd) {
            fnd = traits::find(fnd, last - fnd, first);
            if (!fnd)
                return str::npos;
            if (traits::compare(fnd + 1, pattern, lenPattern) == 0)
                return static_cast<size_t>(fnd - text);
        }
    }
    constexpr size_t find(str_piece pattern, size_t offset = 0) const noexcept {
        return find(pattern.symbols(), pattern.length(), offset);
    }

    template<typename Exc, typename ... Args> requires std::is_constructible_v<Exc, Args...>
    constexpr size_t find_or_throw(str_piece pattern, size_t offset = 0, Args&& ... args) const {
        if (auto fnd = find(pattern.symbols(), pattern.length(), offset); fnd != str::npos) {
            return fnd;
        }
        throw Exc(std::forward<Args>(args)...);
    }

    constexpr size_t find_end(str_piece pattern, size_t offset = 0) const noexcept {
        size_t fnd = find(pattern.symbols(), pattern.length(), offset);
        return fnd == str::npos ? fnd : fnd + pattern.length();
    }

    constexpr size_t find_or_all(str_piece pattern, size_t offset = 0) const noexcept {
        auto fnd = find(pattern.symbols(), pattern.length(), offset);
        return fnd == str::npos ? _len() : fnd;
    }

    constexpr size_t find_end_or_all(str_piece pattern, size_t offset = 0) const noexcept {
        auto fnd = find(pattern.symbols(), pattern.length(), offset);
        return fnd == str::npos ? _len() : fnd + pattern.length();
    }
 
    constexpr size_t find_last(const K* pattern, size_t lenPattern, size_t offset) const noexcept {
        if (lenPattern == 1)
            return find_last(pattern[0], offset);
        size_t lenText = std::min(_len(), offset);
        // Образец, не вмещающийся в строку и пустой образец не находим
        // We don't look for an empty string or a string longer than the text.
        if (!lenPattern || lenPattern > lenText)
            return str::npos;
 
        lenPattern--;
        const K *text = _str() + lenPattern, last = pattern[lenPattern];
        lenText -= lenPattern;
        while(lenText) {
            if (text[--lenText] == last) {
                if (traits::compare(text + lenText - lenPattern, pattern, lenPattern) == 0) {
                    return lenText;
                }
            }
        }
        return str::npos;
    }
    constexpr size_t find_last(str_piece pattern, size_t offset = -1) const noexcept {
        return find_last(pattern.symbols(), pattern.length(), offset);
    }

    constexpr size_t find_end_of_last(str_piece pattern, size_t offset = -1) const noexcept {
        size_t fnd = find_last(pattern.symbols(), pattern.length(), offset);
        return fnd == str::npos ? fnd : fnd + pattern.length();
    }

    constexpr size_t find_last_or_all(str_piece pattern, size_t offset = -1) const noexcept {
        auto fnd = find_last(pattern.symbols(), pattern.length(), offset);
        return fnd == str::npos ? _len() : fnd;
    }

    constexpr size_t find_end_last_or_all(str_piece pattern, size_t offset = -1) const noexcept {
        size_t fnd = find_last(pattern.symbols(), pattern.length(), offset);
        return fnd == str::npos ? _len() : fnd + pattern.length();
    }

    constexpr bool contains(str_piece pattern, size_t offset = 0) const noexcept {
        return find(pattern, offset) != str::npos;
    }

    constexpr size_t find(K s, size_t offset = 0) const noexcept {
        size_t len = _len();
        if (offset < len) {
            const K *str = _str(), *fnd = traits::find(str + offset, len - offset, s);
            if (fnd)
                return static_cast<size_t>(fnd - str);
        }
        return str::npos;
    }

    constexpr size_t find_or_all(K s, size_t offset = 0) const noexcept {
        size_t len = _len();
        if (offset < len) {
            const K *str = _str(), *fnd = traits::find(str + offset, len - offset, s);
            if (fnd)
                return static_cast<size_t>(fnd - str);
        }
        return len;
    }
 
    static const K* find_first_by_case(const K* from, const K* last, K symbol, K symbolInOtherCase) {
        while (from < last) {
            K f = *from;
            if (f == symbol || f == symbolInOtherCase) {
                return from;
            }
            from++;
        }
        return nullptr;
    }

    constexpr size_t find_ia(str_piece pattern, size_t offset = 0) const noexcept {
        size_t lenPattern = pattern.length();
        size_t lenText = _len();
        // Образец, не вмещающийся в строку и пустой образец не находим
        // We don't look for an empty string or a string longer than the text.
        if (!lenPattern || offset >= lenText || offset + lenPattern > lenText)
            return str::npos;
        const K* patternStr = pattern.symbols();
        lenPattern--;
        const K *text = _str(), *last = text + lenText - lenPattern, first = patternStr[0];
        K firstInOtherCase;
        patternStr++;
        bool firstHasCase = isAsciiLower(first);
        if (firstHasCase) {
            firstInOtherCase = first & ~0x20;
        } else if (isAsciiUpper(first)) {
            firstHasCase = true;
            firstInOtherCase = first | 0x20;
        }
 
        auto equal = [&](const K* from) {
            for (size_t idx = 0; idx < lenPattern; idx++) {
                K s1 = from[idx], s2 = patternStr[idx];
                if (s1 == s2)
                    continue;
                if (isAsciiUpper(s1)) {
                    if (s1 == (s2 & ~0x20)) {
                        continue;
                    }
                } else if (isAsciiLower(s1) && s1 == (s2 | 0x20)) {
                    continue;
                }
                return false;
            }
            return true;
        };
 
        for (const K* fnd = text + offset;;) {
            fnd = firstHasCase
                ? find_first_by_case(fnd, last, first, firstInOtherCase)
                : traits::find(fnd, last - fnd, first);
            if (!fnd)
                return str::npos;
            if (equal(++fnd)) {
                return fnd - text - 1;
            }
        }
    }

    constexpr size_t find_ia_lower(str_piece pattern_lower, size_t offset = 0) const noexcept {
        size_t lenPattern = pattern_lower.length();
        size_t lenText = _len();
        // Образец, не вмещающийся в строку и пустой образец не находим
        // We don't look for an empty string or a string longer than the text.
        if (!lenPattern || offset >= lenText || offset + lenPattern > lenText)
            return str::npos;
        const K* patternStr = pattern_lower.symbols();
        lenPattern--;
        const K *text = _str(), *last = text + lenText - lenPattern, first = patternStr[0];
        K firstInOtherCase;
        patternStr++;
        bool firstHasCase = isAsciiLower(first);
        if (firstHasCase) {
            firstInOtherCase = first & ~0x20;
        }
 
        auto equal = [&](const K* from) {
            for (size_t idx = 0; idx < lenPattern; idx++) {
                K s1 = from[idx], s2 = patternStr[idx];
                if (!(s1 == s2 || (isAsciiUpper(s1) && (s1 | 0x20) == s2))) {
                    return false;
                }
            }
            return true;
        };
 
        for (const K* fnd = text + offset;;) {
            fnd = firstHasCase
                ? find_first_by_case(fnd, last, first, firstInOtherCase)
                : traits::find(fnd, last - fnd, first);
            if (!fnd)
                return str::npos;
            if (equal(++fnd)) {
                return fnd - text - 1;
            }
        }
    }
 
    template<typename Op>
    constexpr void for_all_founded(const Op& op, const K* pattern, size_t patternLen, size_t offset, size_t maxCount) const {
        if (!maxCount)
            maxCount--;
        while (maxCount-- > 0) {
            size_t fnd = find(pattern, patternLen, offset);
            if (fnd == str::npos)
                break;
            op(fnd);
            offset = fnd + patternLen;
        }
    }
    template<typename Op>
    constexpr void for_all_founded(const Op& op, str_piece pattern, size_t offset = 0, size_t maxCount = 0) const {
        for_all_founded(op, pattern.symbols(), pattern.length(), offset, maxCount);
    }
 
    template<typename To = std::vector<size_t>>
    constexpr To find_all(const K* pattern, size_t patternLen, size_t offset, size_t maxCount) const {
        To result;
        for_all_founded([&](auto f) { result.emplace_back(f); }, pattern, patternLen, offset, maxCount);
        return result;
    }
    template<typename To = std::vector<size_t>>
    constexpr To find_all(str_piece pattern, size_t offset = 0, size_t maxCount = 0) const {
        return find_all(pattern.symbols(), pattern.length(), offset, maxCount);
    }
    template<typename To = std::vector<size_t>>
    constexpr void find_all_to(To& to, const K* pattern, size_t len, size_t offset = 0, size_t maxCount = 0) const {
        return for_all_founded([&](size_t pos) {
            to.emplace_back(pos);
        }, pattern, len, offset, maxCount);
    }
    constexpr size_t find_last(K s, size_t offset = -1) const noexcept {
        size_t len = std::min(_len(), offset);
        const K *text = _str();
        while (len > 0) {
            if (text[--len] == s)
                return len;
        }
        return str::npos;
    }

    constexpr size_t find_first_of(str_piece pattern, size_t offset = 0) const noexcept {
        return std::basic_string_view<K>{_str(), _len()}.find_first_of(std::basic_string_view<K>{pattern.str, pattern.len}, offset);
    }

    constexpr std::pair<size_t, size_t> find_first_of_idx(str_piece pattern, size_t offset = 0) const noexcept {
        const K* text = _str();
        size_t fnd = std::basic_string_view<K>{text, _len()}.find_first_of(std::basic_string_view<K>{pattern.str, pattern.len}, offset);
        return {fnd, fnd == std::basic_string<K>::npos ? fnd : pattern.find(text[fnd]) };
    }

    constexpr size_t find_first_not_of(str_piece pattern, size_t offset = 0) const noexcept {
        return std::basic_string_view<K>{_str(), _len()}.find_first_not_of(std::basic_string_view<K>{pattern.str, pattern.len}, offset);
    }

    constexpr size_t find_last_of(str_piece pattern, size_t offset = str::npos) const noexcept {
        return std::basic_string_view<K>{_str(), _len()}.find_last_of(std::basic_string_view<K>{pattern.str, pattern.len}, offset);
    }

    constexpr std::pair<size_t, size_t> find_last_of_idx(str_piece pattern, size_t offset = str::npos) const noexcept {
        const K* text = _str();
        size_t fnd = std::basic_string_view<K>{text, _len()}.find_last_of(std::basic_string_view<K>{pattern.str, pattern.len}, offset);
        return {fnd, fnd == std::basic_string<K>::npos ? fnd : pattern.find(text[fnd]) };
    }

    constexpr size_t find_last_not_of(str_piece pattern, size_t offset = str::npos) const noexcept {
        return std::basic_string_view<K>{_str(), _len()}.find_last_not_of(std::basic_string_view<K>{pattern.str, pattern.len}, offset);
    }

    [[deprecated("Use substring(start, end)")]]
    constexpr my_type substr(ptrdiff_t from, ptrdiff_t len = 0) const { // индексация в code units | indexing in code units
        return my_type{d()(from, len)};
    }

    template<typename T, first_index_in_str<K> S, last_index_in_str<K> E> requires std::is_constructible_v<T, str_piece>
    constexpr T slice_to(S start, E end) const noexcept {
        str_piece res = slice(start, end);
        if constexpr (std::is_constructible_v<T, const my_type&> && !std::is_same_v<T, str_piece>) {
            if (res.is_same(*this)) {
                return T{*this};
            }
        }
        return T{res};
    }

    template<first_index_in_str<K> S, last_index_in_str<K> E>
    constexpr my_type substring(S start, E end) const noexcept {
        return slice_to<my_type>(start, end);
    }

    [[deprecated("Use slice_to(start, end)")]]
    constexpr my_type str_mid(size_t from, size_t len = -1) const { // индексация в code units | indexing in code units
        return my_type{d().mid(from, len)};
    }

    template<ToIntNumber T, bool CheckOverflow = true, unsigned Base = 0, bool SkipWs = true, bool AllowSign = true>
    constexpr T as_int() const noexcept {
        auto [res, err, _] = int_convert::to_integer<K, T, Base, CheckOverflow, SkipWs, AllowSign>(_str(), _len());
        return err == IntConvertResult::Overflow ? 0 : res;
    }

    template<ToIntNumber T, bool CheckOverflow = true, unsigned Base = 0, bool SkipWs = true, bool AllowSign = true>
    constexpr convert_result<T> to_int() const noexcept {
        return int_convert::to_integer<K, T, Base, CheckOverflow, SkipWs, AllowSign>(_str(), _len());
    }

    template<bool SkipWS = true, bool AllowPlus = true>
        requires(sizeof(K) == 1 &&
        requires { std::from_chars(std::declval<K*>(), std::declval<K*>(), std::declval<double&>()); })
    std::optional<double> to_double() const noexcept {
        size_t len = _len();
        const K* ptr = _str();
        if constexpr (SkipWS) {
            while (len && uns_type(*ptr) <= ' ') {
                len--;
                ptr++;
            }
        }
        if constexpr (AllowPlus) {
            if (len && *ptr == K('+')) {
                ptr++;
                len--;
            }
        }
        if (!len) {
            return {};
        }
        if constexpr (requires { std::from_chars(std::declval<K*>(), std::declval<K*>(), std::declval<double&>()); }) {
            double d{};
            if (std::from_chars((const K*)ptr, (const K*)ptr + len, d).ec == std::errc{}) {
                return d;
            }
        }
        return {};
    }

    template<bool SkipWS = true>
        requires(sizeof(K) == 1 &&
        requires { std::from_chars(std::declval<K*>(), std::declval<K*>(), std::declval<double&>()); })
    std::optional<double> to_double_hex() const noexcept {
        size_t len = _len();
        const K* ptr = _str();
        if constexpr (SkipWS) {
            while (len && uns_type(*ptr) <= ' ') {
                len--;
                ptr++;
            }
        }
        if (len) {
            if constexpr (requires { std::from_chars(std::declval<K*>(), std::declval<K*>(), std::declval<double&>()); }) {
                double d{};
                if (std::from_chars((const K*)ptr, (const K*)ptr + len, d, std::chars_format::hex).ec == std::errc{}) {
                    return d;
                }
            }
        }
        return {};
    }

    template<ToIntNumber T>
    constexpr void as_number(T& t) const {
        t = as_int<T>();
    }
 
    template<typename T, typename Op>
    constexpr T splitf(const K* delimiter, size_t lendelimiter, const Op& beforeFunc, size_t offset) const {
        size_t mylen = _len();
        std::conditional_t<std::is_same_v<T, void>, char, T> results;
        str_piece me{_str(), mylen};
        for (size_t i = 0;; i++) {
            size_t beginOfDelim = find(delimiter, lendelimiter, offset);
            if (beginOfDelim == str::npos) {
                str_piece last{me.symbols() + offset, me.length() - offset};
                if constexpr (std::is_invocable_v<Op, str_piece&>) {
                    beforeFunc(last);
                }
                if constexpr (requires { results.emplace_back(last); }) {
                    if (last.is_same(me)) {
                        // Пробуем положить весь объект.
                        // Try to put the entire object.
                        results.emplace_back(d());
                    } else {
                        results.emplace_back(last);
                    }
                } else if constexpr (requires { results.push_back(last); }) {
                    if (last.is_same(me)) {
                        // Пробуем положить весь объект.
                        // Try to put the entire object.
                        results.push_back(d());
                    } else {
                        results.push_back(last);
                    }
                } else if constexpr (requires {results[i] = last;} && requires{std::size(results);}) {
                    if (i < std::size(results)) {
                        if (last.is_same(me)) {
                            // Пробуем положить весь объект.
                            // Try to put the entire object.
                            results[i] = d();
                        } else
                            results[i] = last;
                    }
                }
                break;
            }
            str_piece piece{me.symbols() + offset, beginOfDelim - offset};
            if constexpr (std::is_invocable_v<Op, str_piece&>) {
                beforeFunc(piece);
            }
            if constexpr (requires { results.emplace_back(piece); }) {
                results.emplace_back(piece);
            } else if constexpr (requires { results.push_back(piece); }) {
                results.push_back(piece);
            } else if constexpr (requires { results[i] = piece; } && requires{std::size(results);}) {
                if (i < std::size(results)) {
                    results[i] = piece;
                    if (i == results.size() - 1) {
                        break;
                    }
                }
            }
            offset = beginOfDelim + lendelimiter;
        }
        if constexpr (!std::is_same_v<T, void>) {
            return results;
        }
    }
    template<typename T, typename Op>
    constexpr T splitf(str_piece delimiter, const Op& beforeFunc, size_t offset = 0) const {
        return splitf<T>(delimiter.symbols(), delimiter.length(), beforeFunc, offset);
    }

    template<typename T>
    constexpr T split(str_piece delimiter, size_t offset = 0) const {
        return splitf<T>(delimiter.symbols(), delimiter.length(), 0, offset);
    }
 
    // Начинается ли эта строка с указанной подстроки
    // Does this string start with the specified substring
    constexpr bool starts_with(const K* prefix, size_t l) const noexcept {
        return _len() >= l && 0 == traits::compare(_str(), prefix, l);
    }
    constexpr bool starts_with(str_piece prefix) const noexcept {
        return starts_with(prefix.symbols(), prefix.length());
    }

    constexpr bool starts_with_and_ws(str_piece prefix) const noexcept {
        return _len() > prefix.length() &&
            starts_with(prefix) &&
            trim_operator<TrimSides::TrimLeft, K, size_t(-1), true>{}.isTrim(_str()[prefix.length()]);
    }

    constexpr bool starts_with_and_oneof(str_piece prefix, str_piece next_symbol) const noexcept {
        return _len() > prefix.length() &&
            starts_with(prefix) &&
            trim_operator<TrimSides::TrimLeft, K, 0, false>{next_symbol}.isTrim(_str()[prefix.length()]);
    }
    template<typename T, size_t N = const_lit_for<K, T>::Count, StrType<K> From> requires is_const_pattern<N>
    constexpr bool starts_with_and_oneof(str_piece prefix, T&& next_symbol) const noexcept {
        return _len() >= N &&
            starts_with(prefix) &&
            trim_operator<TrimSides::TrimLeft, K, N - 1, false>{next_symbol}.isTrim(_str()[prefix.length()]);
    }
 
    constexpr bool starts_with_ia(const K* prefix, size_t len) const noexcept {
        size_t myLen = _len();
        if (myLen < len) {
            return false;
        }
        const K* ptr1 = _str();
        while (len--) {
            K s1 = *ptr1++, s2 = *prefix++;
            if (s1 == s2)
                continue;
            if (makeAsciiLower(s1) != makeAsciiLower(s2))
                return false;
        }
        return true;
    }
    constexpr bool starts_with_ia(str_piece prefix) const noexcept {
        return starts_with_ia(prefix.symbols(), prefix.length());
    }

    constexpr bool starts_with_ia_and_ws(str_piece prefix) const noexcept {
        return _len() > prefix.length() &&
            starts_with_ia(prefix) &&
            trim_operator<TrimSides::TrimLeft, K, size_t(-1), true>{}.isTrim(_str()[prefix.length()]);
    }

    constexpr bool starts_with_ia_and_oneof(str_piece prefix, str_piece next_symbol) const noexcept {
        return _len() > prefix.length() &&
            starts_with_ia(prefix) &&
            trim_operator<TrimSides::TrimLeft, K, 0, false>{next_symbol}.isTrim(_str()[prefix.length()]);
    }
    template<typename T, size_t N = const_lit_for<K, T>::Count, StrType<K> From> requires is_const_pattern<N>
    constexpr bool starts_with_ia_and_oneof(str_piece prefix, T&& next_symbol) const noexcept {
        return _len() >= N &&
            starts_with_ia(prefix) &&
            trim_operator<TrimSides::TrimLeft, K, N - 1, false>{next_symbol}.isTrim(_str()[prefix.length()]);
    }
 
    // Является ли эта строка началом указанной строки
    // Is this string the beginning of the specified string
    constexpr bool prefix_in(const K* text, size_t len) const noexcept {
        size_t myLen = _len();
        if (myLen > len)
            return false;
        return !myLen || 0 == traits::compare(text, _str(), myLen);
    }
    constexpr bool prefix_in(str_piece text) const noexcept {
        return prefix_in(text.symbols(), text.length());
    }
    // Заканчивается ли строка указанной подстрокой
    // Does the string end with the specified substring
    constexpr bool ends_with(const K* suffix, size_t len) const noexcept {
        size_t myLen = _len();
        return len <= myLen && traits::compare(_str() + myLen - len, suffix, len) == 0;
    }
    constexpr bool ends_with(str_piece suffix) const noexcept {
        return ends_with(suffix.symbols(), suffix.length());
    }
    // Заканчивается ли строка указанной подстрокой без учета регистра ASCII
    // Whether the string ends with the specified substring, case insensitive ASCII
    constexpr bool ends_with_ia(const K* suffix, size_t len) const noexcept {
        size_t myLen = _len();
        if (myLen < len) {
            return false;
        }
        const K* ptr1 = _str() + myLen - len;
        while (len--) {
            K s1 = *ptr1++, s2 = *suffix++;
            if (s1 == s2)
                continue;
            if (makeAsciiLower(s1) != makeAsciiLower(s2))
                return false;
        }
        return true;
    }
    constexpr bool ends_with_ia(str_piece suffix) const noexcept {
        return ends_with_ia(suffix.symbols(), suffix.length());
    }

    constexpr bool is_ascii() const noexcept {
        if (_is_empty())
            return true;
        if (std::is_constant_evaluated()) {
            for (size_t idx = 0; idx < _len(); idx++) {
                if (uns_type(_str()[idx]) > 127) {
                    return false;
                }
            }
            return true;
        }
        const int sl = ascii_mask<K>::WIDTH;
        const size_t mask = ascii_mask<K>::VALUE;
        size_t len = _len();
        const uns_type* ptr = reinterpret_cast<const uns_type*>(_str());
        if constexpr (sl > 1) {
            const size_t roundMask = sizeof(size_t) - 1;
            while (len >= sl && (reinterpret_cast<size_t>(ptr) & roundMask) != 0) {
                if (*ptr++ > 127)
                    return false;
                len--;
            }
            while (len >= sl) {
                if (*reinterpret_cast<const size_t*>(ptr) & mask)
                    return false;
                ptr += sl;
                len -= sl;
            }
        }
        while (len--) {
            if (*ptr++ > 127)
                return false;
        }
        return true;
    }

    template<typename R = my_type>
    R upperred_only_ascii() const {
        return R::upperred_only_ascii_from(d());
    }

    template<typename R = my_type>
    R lowered_only_ascii() const {
        return R::lowered_only_ascii_from(d());
    }

    template<typename R = my_type>
    R replaced(str_piece pattern, str_piece repl, size_t offset = 0, size_t maxCount = 0) const {
        return R::replaced_from(d(), pattern, repl, offset, maxCount);
    }

    template<typename R = str_piece>
    constexpr std::optional<R> strip_prefix(str_piece prefix) const {
        if (starts_with(prefix)) {
            return R{slice(prefix.length(), to_end)};
        }
        return {};
    }

    template<typename R = str_piece>
    constexpr std::optional<R> strip_prefix_ia(str_piece prefix) const {
        if (starts_with_ia(prefix)) {
            return R{slice(prefix.length(), to_end)};
        }
        return {};
    }

    template<typename R = str_piece>
    constexpr std::optional<R> strip_suffix(str_piece suffix) const {
        if (ends_with(suffix)) {
            return R{slice(0, from_end{suffix.length()})};
        }
        return {};
    }

    template<typename R = str_piece>
    constexpr std::optional<R> strip_suffix_ia(str_piece suffix) const {
        if (ends_with_ia(suffix)) {
            return R{slice(0, from_end{suffix.length()})};
        }
        return {};
    }
 
    template<StrType<K> From>
    constexpr static my_type make_trim_op(const From& from, const auto& opTrim) {
        str_piece sfrom = from, newPos = opTrim(sfrom);
        if (newPos.is_same(sfrom)) {
            my_type res = from;
            return res;
        }
        return my_type{newPos};
    }
    template<TrimSides S, StrType<K> From>
    constexpr static my_type trim_static(const From& from) {
        return make_trim_op(from, trim_operator<S, K, static_cast<size_t>(-1), true>{});
    }
 
    template<TrimSides S, bool withSpaces, typename T, size_t N = const_lit_for<K, T>::Count, StrType<K> From>
        requires is_const_pattern<N>
    constexpr static my_type trim_static(const From& from, T&& pattern) {
        return make_trim_op(from, trim_operator<S, K, N - 1, withSpaces>{pattern});
    }
 
    template<TrimSides S, bool withSpaces, StrType<K> From>
    constexpr static my_type trim_static(const From& from, str_piece pattern) {
        return make_trim_op(from, trim_operator<S, K, 0, withSpaces>{{pattern}});
    }
    template<typename R = str_piece>
    constexpr R trimmed() const {
        return R::template trim_static<TrimSides::TrimAll>(d());
    }

    template<typename R = str_piece>
    constexpr R trimmed_left() const {
        return R::template trim_static<TrimSides::TrimLeft>(d());
    }

    template<typename R = str_piece>
    constexpr R trimmed_right() const {
        return R::template trim_static<TrimSides::TrimRight>(d());
    }

    template<typename R = str_piece, typename T, size_t N = const_lit_for<K, T>::Count>
        requires is_const_pattern<N>
    constexpr R trimmed(T&& pattern) const {
        return R::template trim_static<TrimSides::TrimAll, false>(d(), pattern);
    }

    template<typename R = str_piece, typename T, size_t N = const_lit_for<K, T>::Count>
        requires is_const_pattern<N>
    constexpr R trimmed_left(T&& pattern) const {
        return R::template trim_static<TrimSides::TrimLeft, false>(d(), pattern);
    }

    template<typename R = str_piece, typename T, size_t N = const_lit_for<K, T>::Count>
        requires is_const_pattern<N>
    constexpr R trimmed_right(T&& pattern) const {
        return R::template trim_static<TrimSides::TrimRight, false>(d(), pattern);
    }
    // Триминг по символам в литерале и пробелам
    // Trimming by characters in literal and spaces

    template<typename R = str_piece, typename T, size_t N = const_lit_for<K, T>::Count>
        requires is_const_pattern<N>
    constexpr R trimmed_with_spaces(T&& pattern) const {
        return R::template trim_static<TrimSides::TrimAll, true>(d(), pattern);
    }

    template<typename R = str_piece, typename T, size_t N = const_lit_for<K, T>::Count>
        requires is_const_pattern<N>
    constexpr R trimmed_left_with_spaces(T&& pattern) const {
        return R::template trim_static<TrimSides::TrimLeft, true>(d(), pattern);
    }

    template<typename R = str_piece, typename T, size_t N = const_lit_for<K, T>::Count>
        requires is_const_pattern<N>
    constexpr R trimmed_right_with_spaces(T&& pattern) const {
        return R::template trim_static<TrimSides::TrimRight, true>(d(), pattern);
    }
    // Триминг по динамическому источнику
    // Trimming by dynamic source

    template<typename R = str_piece>
    constexpr R trimmed(str_piece pattern) const {
        return R::template trim_static<TrimSides::TrimAll, false>(d(), pattern);
    }

    template<typename R = str_piece>
    constexpr R trimmed_left(str_piece pattern) const {
        return R::template trim_static<TrimSides::TrimLeft, false>(d(), pattern);
    }

    template<typename R = str_piece>
    constexpr R trimmed_right(str_piece pattern) const {
        return R::template trim_static<TrimSides::TrimRight, false>(d(), pattern);
    }

    template<typename R = str_piece>
    constexpr R trimmed_with_spaces(str_piece pattern) const {
        return R::template trim_static<TrimSides::TrimAll, true>(d(), pattern);
    }

    template<typename R = str_piece>
    constexpr R trimmed_left_with_spaces(str_piece pattern) const {
        return R::template trim_static<TrimSides::TrimLeft, true>(d(), pattern);
    }

    template<typename R = str_piece>
    constexpr R trimmed_right_with_spaces(str_piece pattern) const {
        return R::template trim_static<TrimSides::TrimRight, true>(d(), pattern);
    }

    template<typename R = str_piece>
    constexpr R trimmed_prefix(str_piece prefix, size_t max_count = 0) const {
        str_piece res = *this;
        while(res.starts_with(prefix)) {
            res.remove_prefix(prefix.length());
            if (--max_count == 0) {
                break;
            }
        }
        return res;
    }

    template<typename R = str_piece>
    constexpr R trimmed_prefix_ia(str_piece prefix, size_t max_count = 0) const {
        str_piece res = *this;
        while(res.starts_with_ia(prefix)) {
            res.remove_prefix(prefix.length());
            if (--max_count == 0) {
                break;
            }
        }
        return res;
    }

    template<typename R = str_piece>
    constexpr R trimmed_suffix(str_piece suffix) const {
        str_piece res = *this;
        while(res.ends_with(suffix)) {
            res.remove_suffix(suffix.length());
        }
        return res;
    }

    template<typename R = str_piece>
    constexpr R trimmed_suffix_ia(str_piece suffix) const {
        str_piece res = *this;
        while(res.ends_with_ia(suffix)) {
            res.remove_suffix(suffix.length());
        }
        return res;
    }

    constexpr SplitterBase<K, str_piece> splitter(str_piece delimiter) const {
        return SplitterBase<K, str_piece>{*this, delimiter};
    }
};
 
template<size_t N> requires (N > 1)
struct find_all_container {
    static constexpr size_t max_capacity = N;
    size_t positions_[N];
    size_t added_{};
 
    constexpr void emplace_back(size_t pos) {
        positions_[added_++] = pos;
    }
};

template<typename K>
struct str_src : str_src_algs<K, str_src<K>, str_src<K>, false> {
    using symb_type = K;
    using my_type = str_src<K>;
 
    const symb_type* str;
    size_t len;
 
    str_src() = default;
    template<typename T, size_t N = const_lit_for<K, T>::Count>
    constexpr str_src(T&& v) noexcept : str((const K*)v), len(N - 1) {}

    constexpr str_src(const K* p, size_t l) noexcept : str(p), len(l) {}
 
    template<StrType<K> T>
    constexpr str_src(T&& t) : str(t.symbols()), len(t.length()){}

    template<typename A>
    constexpr str_src(const std::basic_string<K, std::char_traits<K>, A>& s) noexcept : str(s.data()), len(s.length()) {}
    constexpr str_src(const std::basic_string_view<K, std::char_traits<K>>& s) noexcept : str(s.data()), len(s.length()) {}

    constexpr size_t length() const noexcept {
        return len;
    }

    constexpr const symb_type* symbols() const noexcept {
        return str;
    }

    constexpr bool is_empty() const noexcept {
        return len == 0;
    }

    constexpr bool is_same(str_src<K> other) const noexcept {
        return str == other.str && len == other.len;
    }

    constexpr bool is_part_of(str_src<K> other) const noexcept {
        return str >= other.str && str + len <= other.str + other.len;
    }

    constexpr K operator[](size_t idx) const {
        return str[idx];
    }

    constexpr my_type& remove_prefix(size_t delta) {
        str += delta;
        len -= delta;
        return *this;
    }

    constexpr my_type& remove_suffix(size_t delta) {
        len -= delta;
        return *this;
    }
};

template<typename K>
struct str_src_nt : str_src<K>, null_terminated<K, str_src_nt<K>> {
    using symb_type = K;
    using my_type = str_src_nt<K>;
    using base = str_src<K>;
 
    constexpr static const K empty_string[1] = {0};
 
    str_src_nt() = default;
    template<typename T> requires std::is_same_v<std::remove_const_t<std::remove_pointer_t<std::remove_cvref_t<T>>>, K>
    constexpr explicit str_src_nt(T&& p) noexcept {
        base::len = p ? static_cast<size_t>(base::traits::length(p)) : 0;
        base::str = base::len ? p : empty_string;
    }

    template<typename T, size_t N = const_lit_for<K, T>::Count>
    constexpr str_src_nt(T&& v) noexcept : base(std::forward<T>(v)) {}

    constexpr str_src_nt(const K* p, size_t l) noexcept : base(p, l) {}
 
    template<StrType<K> T>
    constexpr str_src_nt(T&& t) {
        base::str = t.symbols();
        base::len = t.length();
    }
    template<typename A>
    constexpr str_src_nt(const std::basic_string<K, std::char_traits<K>, A>& s) noexcept : base(s) {}
 
    static const my_type empty_str;
    constexpr my_type to_nts(size_t from) {
        if (from > base::len) {
            from = base::len;
        }
        return {base::str + from, base::len - from};
    }
};
 
template<typename K>
inline const str_src_nt<K> str_src_nt<K>::empty_str{str_src_nt<K>::empty_string, 0};
template<typename K> struct simple_str_selector;
 
inline namespace literals {
template<char...Chars>
SS_CONSTEVAL auto operator""_fmt() {
    return f::skip_0x<Chars...>();
}
 
} // namespace literals
 
#ifndef IN_FULL_SIMSTR
 
template<typename K>
using simple_str = str_src<K>;
 
template<typename K>
struct simple_str_selector {
    using type = simple_str<K>;
};
 
template<typename K>
using simple_str_nt = str_src_nt<K>;
 
template<typename K>
using Splitter = SplitterBase<K, str_src<K>>;
 
using ssa = str_src<u8s>;
using ssb = str_src<ubs>;
using ssw = str_src<wchar_t>;
using ssu = str_src<u16s>;
using ssuu = str_src<u32s>;
using stra = str_src_nt<u8s>;
using strb = str_src_nt<ubs>;
using strw = str_src_nt<wchar_t>;
using stru = str_src_nt<u16s>;
using struu = str_src_nt<u32s>;
 
template<typename K>
consteval simple_str_nt<K> select_str(simple_str_nt<u8s> s8, simple_str_nt<ubs> sb, simple_str_nt<uws> sw, simple_str_nt<u16s> s16, simple_str_nt<u32s> s32) {
    if constexpr (std::is_same_v<K, u8s>)
        return s8;
    if constexpr (std::is_same_v<K, ubs>)
        return sb;
    if constexpr (std::is_same_v<K, uws>)
        return sw;
    if constexpr (std::is_same_v<K, u16s>)
        return s16;
    if constexpr (std::is_same_v<K, u32s>)
        return s32;
}
 
#define uni_string(K, p) select_str<K>(p, u8##p, L##p, u##p, U##p)
 
inline namespace literals {

SS_CONSTEVAL str_src_nt<u8s> operator""_ss(const u8s* ptr, size_t l) {
    return str_src_nt<u8s>{ptr, l};
}

SS_CONSTEVAL str_src_nt<ubs> operator""_ss(const ubs* ptr, size_t l) {
    return str_src_nt<ubs>{ptr, l};
}

SS_CONSTEVAL str_src_nt<uws> operator""_ss(const uws* ptr, size_t l) {
    return str_src_nt<uws>{ptr, l};
}

SS_CONSTEVAL str_src_nt<u16s> operator""_ss(const u16s* ptr, size_t l) {
    return str_src_nt<u16s>{ptr, l};
}

SS_CONSTEVAL str_src_nt<u32s> operator""_ss(const u32s* ptr, size_t l) {
    return str_src_nt<u32s>{ptr, l};
}
 
} // namespace literals
 
#endif
 
template<typename K>
constexpr size_t slice_simple_find_func(str_src<K> str, str_src<K> pattern, size_t offset){return str.find(pattern, offset);}
template<typename K>
constexpr size_t slice_simple_find_rev_func(str_src<K> str, str_src<K> pattern, size_t offset){return str.find_last(pattern, offset);}
 
template<typename K, bool ToEndOfPattern, bool OffsetFromFound, bool AllAtFail, auto F = slice_simple_find_func<K>>
struct slice_simple_find : slice_find<str_src<K>, ToEndOfPattern, OffsetFromFound, AllAtFail, false, F> {
    using slice_find<str_src<K>, ToEndOfPattern, OffsetFromFound, AllAtFail, false, F>::slice_find;
};
 
template<typename K>
struct begin_or_all : slice_simple_find<K, false, true, true> {
    using base = slice_simple_find<K, false, true, true>;
    using base::base;
};
template<typename K>
struct end_or_all : slice_simple_find<K, true, true, true> {
    using base = slice_simple_find<K, true, true, true>;
    using base::base;
};
 
template<typename K>
struct begin_or_empty : slice_simple_find<K, false, true, false> {
    using base = slice_simple_find<K, false, true, false>;
    using base::base;
};
template<typename K>
struct end_or_empty : slice_simple_find<K, true, true, false> {
    using base = slice_simple_find<K, true, true, false>;
    using base::base;
};
 
template<typename K, bool ToEndOfPattern, bool OffsetFromFound, bool AllAtFail, auto F = slice_simple_find_rev_func<K>>
struct slice_simple_find_rev : slice_find<str_src<K>, ToEndOfPattern, OffsetFromFound, AllAtFail, true, F> {
    using slice_find<str_src<K>, ToEndOfPattern, OffsetFromFound, AllAtFail, true, F>::slice_find;
};
 
template<typename K>
struct begin_last_or_all : slice_simple_find_rev<K, false, false, true> {
    using base = slice_simple_find_rev<K, false, false, true>;
    using base::base;
};
 
template<typename K>
struct end_last_or_all : slice_simple_find_rev<K, true, false, true> {
    using base = slice_simple_find_rev<K, true, false, true>;
    using base::base;
};
 
template<typename K>
struct begin_last_or_empty : slice_simple_find_rev<K, false, false, false> {
    using base = slice_simple_find_rev<K, false, false, false>;
    using base::base;
};
 
template<typename K>
struct end_last_or_empty : slice_simple_find_rev<K, true, false, false> {
    using base = slice_simple_find_rev<K, true, false, false>;
    using base::base;
};
 
#define CTAD_SLICE_FIND(name) template<StrSource S> name(S&&) -> name<symb_type_from_src_t<S>>;\
    template<StrSource S> name(S&&, size_t) -> name<symb_type_from_src_t<S>>;\
    template<StrSource S> name(S&&, size_t, size_t) -> name<symb_type_from_src_t<S>>
 
CTAD_SLICE_FIND(begin_or_all);
CTAD_SLICE_FIND(end_or_all);
CTAD_SLICE_FIND(begin_or_empty);
CTAD_SLICE_FIND(end_or_empty);
CTAD_SLICE_FIND(begin_last_or_all);
CTAD_SLICE_FIND(end_last_or_all);
CTAD_SLICE_FIND(begin_last_or_empty);
CTAD_SLICE_FIND(end_last_or_empty);
 
inline namespace literals {
 
#define FIND_LITERAL(name, type, suffix) SS_CONSTEVAL name<type> operator ""_##suffix(const type* ptr, size_t l) {return str_src<type>{ptr, l};}
#define FIND_LITERALS(name, suffix) \
    FIND_LITERAL(name, u8s, suffix) \
    FIND_LITERAL(name, ubs, suffix) \
    FIND_LITERAL(name, u16s, suffix) \
    FIND_LITERAL(name, u32s, suffix) \
    FIND_LITERAL(name, wchar_t, suffix)
 
FIND_LITERALS(begin_or_all, boa)             // Begin of pattern Or All
FIND_LITERALS(end_or_all, eoa)               // End of pattern Or All
FIND_LITERALS(begin_or_empty, boe)           // Begin of pattern Or Empty
FIND_LITERALS(end_or_empty, eoe)             // End of pattern Or Empty
FIND_LITERALS(begin_last_or_all, bloa)       // Begin of Last pattern Or All
FIND_LITERALS(end_last_or_all, eloa)         // End of Last pattern Or All
FIND_LITERALS(begin_last_or_empty, bloe)     // Begin of Last pattern Or Empty
FIND_LITERALS(end_last_or_empty, eloe)       // End of Last pattern Or Empty
 
} // namespace literals
 
template<typename K, bool withSpaces>
struct CheckSpaceTrim {
    constexpr bool is_trim_spaces(K s) const {
        return s == ' ' || (s >= 9 && s <= 13); // || isspace(s);
    }
};
template<typename K>
struct CheckSpaceTrim<K, false> {
    constexpr bool is_trim_spaces(K) const {
        return false;
    }
};
 
template<typename K>
struct CheckSymbolsTrim {
    str_src<K> symbols;
    constexpr bool is_trim_symbols(K s) const {
        return symbols.len != 0 && str_src<K>::traits::find(symbols.str, symbols.len, s) != nullptr;
    }
};
 
template<typename K, size_t N>
struct CheckConstSymbolsTrim {
    const const_lit_to_array<K, N> symbols;
 
    template<typename T, size_t M = const_lit_for<K, T>::Count> requires (M == N + 1)
    constexpr CheckConstSymbolsTrim(T&& s) : symbols(std::forward<T>(s)) {}
 
    constexpr bool is_trim_symbols(K s) const noexcept {
        return symbols.contain(s);
    }
};
 
template<typename K>
struct CheckConstSymbolsTrim<K, 0> {
    constexpr bool is_trim_symbols(K) const {
        return false;
    }
};
 
template<typename K, size_t N>
struct SymbSelector {
    using type = CheckConstSymbolsTrim<K, N>;
};
 
template<typename K>
struct SymbSelector<K, 0> {
    using type = CheckSymbolsTrim<K>;
};
 
template<typename K>
struct SymbSelector<K, static_cast<size_t>(-1)> {
    using type = CheckConstSymbolsTrim<K, 0>;
};
 
template<TrimSides S, typename K, size_t N, bool withSpaces>
struct trim_operator : SymbSelector<K, N>::type, CheckSpaceTrim<K, withSpaces> {
    constexpr bool isTrim(K s) const {
        return CheckSpaceTrim<K, withSpaces>::is_trim_spaces(s) || SymbSelector<K, N>::type::is_trim_symbols(s);
    }
    constexpr str_src<K> operator()(str_src<K> from) const {
        if constexpr ((S & TrimSides::TrimLeft) != 0) {
            while (from.len) {
                if (isTrim(*from.str)) {
                    from.str++;
                    from.len--;
                } else
                    break;
            }
        }
        if constexpr ((S & TrimSides::TrimRight) != 0) {
            const K* back = from.str + from.len - 1;
            while (from.len) {
                if (isTrim(*back)) {
                    back--;
                    from.len--;
                } else
                    break;
            }
        }
        return from;
    }
};
 
template<TrimSides S, typename K>
using SimpleTrim = trim_operator<S, K, size_t(-1), true>;
 
template<TrimSides S = TrimSides::TrimAll, bool withSpaces = false, typename K, typename T, size_t N = const_lit_for<K, T>::Count>
    requires is_const_pattern<N>
constexpr inline auto trimOp(T&& pattern) {
    return trim_operator<S, K, N - 1, withSpaces>{pattern};
}
 
template<TrimSides S = TrimSides::TrimAll, bool withSpaces = false, typename K>
constexpr inline auto trimOp(str_src<K> pattern) {
    return trim_operator<S, K, 0, withSpaces>{pattern};
}
 
static constexpr size_t FIND_CACHE_SIZE = 16;
 
template<typename K, size_t N, size_t L>
struct expr_replaces : expr_to_std_string<expr_replaces<K, N, L>> {
    using symb_type = K;
    using my_type = expr_replaces<K, N, L>;
    str_src<K> what;
    const K(&pattern)[N + 1];
    const K(&repl)[L + 1];
    mutable find_all_container<FIND_CACHE_SIZE> matches_;
    mutable size_t last_;
 
    constexpr expr_replaces(str_src<K> w, const K(&p)[N + 1], const K(&r)[L + 1]) : what(w), pattern(p), repl(r) {}
 
    constexpr size_t length() const {
        size_t l = what.length();
        if constexpr (N == L) {
            return l;
        }
        what.find_all_to(matches_, pattern, N, 0, FIND_CACHE_SIZE);
        if (matches_.added_) {
            last_ = matches_.positions_[matches_.added_ - 1] + N;
            l += int(L - N) * matches_.added_;
 
            if (matches_.added_ == FIND_CACHE_SIZE) {
                for (;;) {
                    size_t next = what.find(pattern, N, last_);
                    if (next == str::npos) {
                        break;
                    }
                    last_ = next + N;
                    l += L - N;
                }
            }
        }
        if (!l) {
            matches_.added_ = -1;
        }
        return l;
    }
    constexpr K* place(K* ptr) const noexcept {
        if constexpr (N == L) {
            const K* from = what.symbols();
            for (size_t start = 0; start < what.length();) {
                size_t next = what.find(pattern, N, start);
                if (next == str::npos) {
                    next = what.length();
                }
                size_t delta = next - start;
                ch_traits<K>::copy(ptr,  from + start, delta);
                ptr += delta;
                ch_traits<K>::copy(ptr, repl, L);
                ptr += L;
                start = next + N;
            }
            return ptr;
        }
        if (matches_.added_ == 0) {
            return what.place(ptr);
        } else if (matches_.added_ == size_t(-1)) {
            // after replaces text become empty
            return ptr;
        }
        const K* from = what.symbols();
        for (size_t start = 0, offset = matches_.positions_[0], idx = 1; ;) {
            ch_traits<K>::copy(ptr, from + start, offset - start);
            ptr += offset - start;
            ch_traits<K>::copy(ptr, repl, L);
            ptr += L;
            start = offset + N;
            if (start >= last_) {
                size_t tail = what.length() - last_;
                ch_traits<K>::copy(ptr, from + last_, tail);
                ptr += tail;
                break;
            } else {
                offset = idx < FIND_CACHE_SIZE ? matches_.positions_[idx++] : what.find(pattern, N, start);
            }
        }
        return ptr;
    }
};

template<StrSource A, typename K = symb_type_from_src_t<A>, typename T, size_t N = const_lit_for<K, T>::Count, typename X, size_t L = const_lit_for<K, X>::Count>
    requires(N > 1)
constexpr auto e_repl(A&& w, T&& p, X&& r) {
    return expr_replaces<K, N - 1, L - 1>{std::forward<A>(w), p, r};
}

template<typename K>
struct expr_replaced : expr_to_std_string<expr_replaced<K>> {
    using symb_type = K;
    using my_type = expr_replaced<K>;
    str_src<K> what;
    const str_src<K> pattern;
    const str_src<K> repl;
    mutable find_all_container<FIND_CACHE_SIZE> matches_;
    mutable size_t last_;
    constexpr expr_replaced(str_src<K> w, str_src<K> p, str_src<K> r) : what(w), pattern(p), repl(r) {}
 
    constexpr size_t length() const {
        size_t l = what.length(), plen = pattern.length(), rlen = repl.length();
        if (!plen || plen == rlen) {
            return l;
        }
        what.find_all_to(matches_, pattern.symbols(), plen, 0, FIND_CACHE_SIZE);
        if (matches_.added_) {
            last_ = matches_.positions_[matches_.added_ - 1] + plen;
            l += int(rlen - plen) * matches_.added_;
 
            if (matches_.added_ == FIND_CACHE_SIZE) {
                for (;;) {
                    size_t next = what.find(pattern.symbols(), plen, last_);
                    if (next == str::npos) {
                        break;
                    }
                    last_ = next + plen;
                    l += rlen - plen;
                }
            }
        }
        if (!l) {
            matches_.added_ = -1;
        }
        return l;
    }
    constexpr K* place(K* ptr) const noexcept {
        size_t plen = pattern.length(), rlen = repl.length();
        if (plen == rlen) {
            const K* from = what.symbols();
            for (size_t start = 0; start < what.length();) {
                size_t next = what.find(pattern, start);
                if (next == str::npos) {
                    next = what.length();
                }
                size_t delta = next - start;
                ch_traits<K>::copy(ptr,  from + start, delta);
                ptr += delta;
                ch_traits<K>::copy(ptr, repl.symbols(), rlen);
                ptr += rlen;
                start = next + plen;
            }
            return ptr;
        }
        if (matches_.added_ == 0) {
            return what.place(ptr);
        } else if (matches_.added_ == -1) {
            // after replaces text become empty
            return ptr;
        }
        const K* from = what.symbols();
        for (size_t start = 0, offset = matches_.positions_[0], idx = 1; ;) {
            ch_traits<K>::copy(ptr, from + start, offset - start);
            ptr += offset - start;
            ch_traits<K>::copy(ptr, repl.symbols(), rlen);
            ptr += rlen;
            start = offset + plen;
            if (start >= last_) {
                size_t tail = what.length() - start;
                ch_traits<K>::copy(ptr, from + start, tail);
                ptr += tail;
                break;
            } else {
                offset = idx < FIND_CACHE_SIZE ? matches_.positions_[idx++] : what.find(pattern.symbols(), plen, start);
            }
        }
        return ptr;
    }
};

template<typename K, StrExprForType<K> E>
struct expr_replaced_e : expr_to_std_string<expr_replaced_e<K, E>> {
    using symb_type = K;
    using my_type = expr_replaced<K>;
    str_src<K> what;
    const str_src<K> pattern;
    mutable size_t replLen;
    mutable find_all_container<FIND_CACHE_SIZE> matches_;
    mutable size_t last_;
    const E& expr;
    constexpr expr_replaced_e(str_src<K> w, str_src<K> p, const E& e) : what(w), pattern(p), expr(e) {}
 
    constexpr size_t length() const {
        size_t l = what.length(), plen = pattern.length();
        if (!plen) {
            return l;
        }
        matches_.positions_[0] = what.find(pattern);
        if (matches_.positions_[0] == -1) {
            // Не нашли вхождений, нечего менять
            return l;
        }
        matches_.added_ = 1;
        // Вхождение есть, надо теперь получить длину замены
        replLen = expr.length();
        if (replLen == plen) {
            // Замена той же длины, общая длина не изменится
            return l;
        }
        what.find_all_to(matches_, pattern.symbols(), plen, matches_.positions_[0] + plen, FIND_CACHE_SIZE - 1);
 
        last_ = matches_.positions_[matches_.added_ - 1] + plen;
        l += int(replLen - plen) * matches_.added_;
 
        if (matches_.added_ == FIND_CACHE_SIZE) {
            for (;;) {
                size_t next = what.find(pattern.symbols(), plen, last_);
                if (next == str::npos) {
                    break;
                }
                last_ = next + plen;
                l += replLen - plen;
            }
        }
        if (!l) {
            matches_.added_ = -1;
        }
        return l;
    }
    constexpr K* place(K* ptr) const noexcept {
        if (matches_.added_ == 0) {
            // не было найдено вхождений
            return what.place(ptr);
        } else if (matches_.added_ == -1) {
            // Строка стала пустой
            return ptr;
        }
        size_t plen = pattern.length();
        const K* from = what.symbols();
        ch_traits<K>::copy(ptr, from, matches_.positions_[0]);
        ptr += matches_.positions_[0];
        const K* repl = ptr;
        expr.place((typename E::symb_type*)ptr);
        ptr += replLen;
        size_t start = matches_.positions_[0] + plen;
 
        if (plen == replLen) {
            for (;;) {
                size_t next = what.find(pattern, start);
                if (next == str::npos) {
                    break;
                }
                size_t delta = next - start;
                ch_traits<K>::copy(ptr, from + start, delta);
                ptr += delta;
                ch_traits<K>::copy(ptr, repl, replLen);
                ptr += replLen;
                start = next + plen;
            }
        } else {
            for (size_t idx = 1;;) {
                if (start >= last_) {
                    break;
                }
                size_t next = idx < FIND_CACHE_SIZE ? matches_.positions_[idx++] : what.find(pattern, start);
                size_t delta = next - start;
                ch_traits<K>::copy(ptr, from + start, delta);
                ptr += delta;
                ch_traits<K>::copy(ptr, repl, replLen);
                ptr += replLen;
                start = next + plen;
            }
        }
        size_t tail = what.length() - start;
        ch_traits<K>::copy(ptr, from + start, tail);
        return ptr + tail;
    }
};

template<StrSource A, typename K = symb_type_from_src_t<A>, typename T, typename X>
    requires (std::is_constructible_v<str_src<K>, T> && std::is_constructible_v<str_src<K>, X> && (!is_const_lit_v<T> || !is_const_lit_v<X>))
constexpr auto e_repl(A&& w, T&& p, X&& r) {
    str_src<K> pattern{std::forward<T>(p)};
    str_src<K> repl{std::forward<X>(r)};
    return expr_replaced<K>{std::forward<A>(w), pattern, repl};
}

template<StrSource A, typename K = symb_type_from_src_t<A>, typename T, StrExprForType<K> E>
    requires std::is_constructible_v<str_src<K>, T>
constexpr auto e_repl(A&& w, T&& p, const E& expr) {
    str_src<K> pattern{std::forward<T>(p)};
    return expr_replaced_e<K, E>{std::forward<A>(w), pattern, expr};
}
 
template<bool UseVectorForReplace>
struct replace_search_result_store {
    size_t count_{};
    std::pair<size_t, size_t> replaces_[16];
};
 
template<>
struct replace_search_result_store<true> : std::vector<std::pair<size_t, size_t>> {};
 
// Строковое выражение для замены символов
// String expression to replace characters
template<typename K, size_t N, bool UseVectorForReplace>
struct expr_replace_const_symbols : expr_to_std_string<expr_replace_const_symbols<K, N, UseVectorForReplace>> {
    using symb_type = K;
    inline static const int BIT_SEARCH_TRESHHOLD = 4;
    const K pattern_[N];
    const str_src<K> source_;
    const str_src<K> replaces_[N];
 
    mutable replace_search_result_store<UseVectorForReplace> search_results_;
 
    [[_no_unique_address]]
    std::array<uu8s, N >= BIT_SEARCH_TRESHHOLD ? (sizeof(K) == 1 ? 32 : 64) : 0> bit_mask_{};
 
    template<typename ... Repl> requires (sizeof...(Repl) == N * 2)
    constexpr expr_replace_const_symbols(str_src<K> source, Repl&& ... repl) : expr_replace_const_symbols(0, source, std::forward<Repl>(repl)...) {}
 
    size_t length() const {
        size_t l = source_.length();
        auto [fnd, num] = find_first_of(source_.str, source_.len);
        if (fnd == str::npos) {
            return l;
        }
        l += replaces_[num].len - 1;
        if constexpr (UseVectorForReplace) {
            search_results_.reserve((l >> 4) + 8);
            search_results_.emplace_back(fnd, num);
            for (size_t start = fnd + 1;;) {
                auto [fnd, idx] = find_first_of(source_.str, source_.len, start);
                if (fnd == str::npos) {
                    break;
                }
                search_results_.emplace_back(fnd, idx);
                start = fnd + 1;
                l += replaces_[idx].len - 1;
            }
        } else {
            const size_t max_store = std::size(search_results_.replaces_);
            search_results_.replaces_[0] = {fnd, num};
            search_results_.count_++;
            for (size_t start = fnd + 1;;) {
                auto [found, idx] = find_first_of(source_.str, source_.len, start);
                if (found == str::npos) {
                    break;
                }
                if (search_results_.count_ < max_store) {
                    search_results_.replaces_[search_results_.count_] = {found, idx};
                }
                l += replaces_[idx].len - 1;
                search_results_.count_++;
                start = found + 1;
            }
        }
        return l;
    }
    K* place(K* ptr) const noexcept {
        size_t start = 0;
        const K* text = source_.str;
        if constexpr (UseVectorForReplace) {
            for (const auto& [pos, num] : search_results_) {
                size_t delta = pos - start;
                ch_traits<K>::copy(ptr, text + start, delta);
                ptr += delta;
                ptr = replaces_[num].place(ptr);
                start = pos + 1;
            }
        } else {
            const size_t max_store = std::size(search_results_.replaces_);
            size_t founded = search_results_.count_;
            for (size_t idx = 0, stop = std::min(founded, max_store); idx < stop; idx++) {
                const auto [pos, num] = search_results_.replaces_[idx];
                size_t delta = pos - start;
                ch_traits<K>::copy(ptr, text + start, delta);
                ptr += delta;
                ptr = replaces_[num].place(ptr);
                start = pos + 1;
            }
            if (founded > max_store) {
                founded  -= max_store;
                while (founded--) {
                    auto [fnd, idx] = find_first_of(source_.str, source_.len, start);
                    size_t delta = fnd - start;
                    ch_traits<K>::copy(ptr, text + start, delta);
                    ptr += delta;
                    ptr = replaces_[idx].place(ptr);
                    start = fnd + 1;
                }
            }
        }
        size_t tail = source_.len - start;
        ch_traits<K>::copy(ptr, text + start, tail);
        return ptr + tail;
    }
 
protected:
    template<typename ... Repl>
    constexpr expr_replace_const_symbols(int, str_src<K> source, K s, str_src<K> r, Repl&&... repl) :
        expr_replace_const_symbols(0, source, std::forward<Repl>(repl)..., std::make_pair(s, r)){}
 
    template<typename ... Repl> requires (sizeof...(Repl) == N)
    constexpr expr_replace_const_symbols(int, str_src<K> source, Repl&&... repl) :
        source_(source), pattern_ {repl.first...}, replaces_{repl.second...}
    {
        if constexpr (N >= BIT_SEARCH_TRESHHOLD) {
            for (size_t idx = 0; idx < N; idx++) {
                uu8s s = static_cast<uu8s>(pattern_[idx]);
                if constexpr (sizeof(K) == 1) {
                    bit_mask_[s >> 3] |= 1 << (s & 7);
                } else {
                    if (std::make_unsigned_t<const K>(pattern_[idx]) > 255) {
                        bit_mask_[32 + (s >> 3)] |= 1 << (s & 7);
                    } else {
                        bit_mask_[s >> 3] |= 1 << (s & 7);
                    }
                }
            }
        }
    }
 
    template<size_t Idx>
    size_t index_of(K s) const {
        if constexpr (Idx < N) {
            return pattern_[Idx] == s ? Idx : index_of<Idx + 1>(s);
        }
        return -1;
    }
    bool is_in_mask(uu8s s) const {
        return (bit_mask_[s >> 3] & (1 <<(s & 7))) != 0;
    }
    bool is_in_mask2(uu8s s) const {
        return (bit_mask_[32 + (s >> 3)] & (1 <<(s & 7))) != 0;
    }
    bool is_in_pattern(K s, size_t& idx) const {
        if constexpr (N >= BIT_SEARCH_TRESHHOLD) {
            if constexpr (sizeof(K) == 1) {
                if (is_in_mask(s)) {
                    idx = index_of<0>(s);
                    return true;
                }
            } else {
                if (std::make_unsigned_t<const K>(s) > 255) {
                    if (is_in_mask2(s)) {
                        return (idx = index_of<0>(s)) != -1;
                    }
                } else {
                    if (is_in_mask(s)) {
                        idx = index_of<0>(s);
                        return true;
                    }
                }
            }
        }
        return false;
    }
    std::pair<size_t, size_t> find_first_of(const K* text, size_t len,  size_t offset = 0) const {
        if constexpr (N >= BIT_SEARCH_TRESHHOLD) {
            size_t idx;
            while (offset < len) {
                if (is_in_pattern(text[offset], idx)) {
                    return {offset, idx};
                }
                offset++;
            }
        } else {
            while (offset < len) {
                if (size_t idx = index_of<0>(text[offset]); idx != -1) {
                    return {offset, idx};
                }
                offset++;
            }
        }
        return {-1, -1};
    }
};

template<bool UseVector = false, StrSource A, typename K = symb_type_from_src_t<A>, typename ... Repl>
    requires (sizeof...(Repl) % 2 == 0)
auto e_repl_const_symbols(A&& src, Repl&& ... other) {
    return expr_replace_const_symbols<K, sizeof...(Repl) / 2, UseVector>(std::forward<A>(src), std::forward<Repl>(other)...);
}

template<typename K, bool UseVectorForReplace = false>
struct expr_replace_symbols : expr_to_std_string<expr_replace_symbols<K, UseVectorForReplace>> {
    using symb_type = K;
    using str_t = typename simple_str_selector<K>::type;
    inline static const int BIT_SEARCH_TRESHHOLD = 4;
 
    const str_src<K> source_;
    const std::vector<std::pair<K, str_t>>& replaces_;
 
    std::basic_string<K, ch_traits<K>, std::allocator<K>> pattern_;
 
    mutable replace_search_result_store<UseVectorForReplace> search_results_;
 
    uu8s bit_mask_[sizeof(K) == 1 ? 32 : 64]{};
    constexpr expr_replace_symbols(str_t source, const std::vector<std::pair<K, str_t>>& repl )
        : source_(source), replaces_(repl)
    {
        size_t pattern_len = replaces_.size();
        pattern_.resize(pattern_len);
        K* pattern = pattern_.data();
 
        for (size_t idx = 0; idx < replaces_.size(); idx++) {
            *pattern++ = replaces_[idx].first;
        }
 
        if (pattern_len >= BIT_SEARCH_TRESHHOLD) {
            for (size_t idx = 0; idx < pattern_len; idx++) {
                uu8s s = static_cast<uu8s>(pattern_[idx]);
                if constexpr (sizeof(K) == 1) {
                    bit_mask_[s >> 3] |= (1 << (s & 7));
                } else {
                    if (std::make_unsigned_t<K>(pattern_[idx]) > 255) {
                        bit_mask_[32 + (s >> 3)] |= (1 << (s & 7));
                    } else {
                        bit_mask_[s >> 3] |= (1 << (s & 7));
                    }
                }
            }
        }
    }
 
    size_t length() const {
        size_t l = source_.length();
        auto [fnd, num] = find_first_of(source_.str, source_.len);
        if (fnd == str::npos) {
            return l;
        }
        l += replaces_[num].second.len - 1;
        if constexpr (UseVectorForReplace) {
            search_results_.reserve((l >> 4) + 8);
            search_results_.emplace_back(fnd, num);
            for (size_t start = fnd + 1;;) {
                auto [fnd, idx] = find_first_of(source_.str, source_.len, start);
                if (fnd == str::npos) {
                    break;
                }
                search_results_.emplace_back(fnd, idx);
                start = fnd + 1;
                l += replaces_[idx].second.len - 1;
            }
        } else {
            const size_t max_store = std::size(search_results_.replaces_);
            search_results_.replaces_[0] = {fnd, num};
            search_results_.count_++;
            for (size_t start = fnd + 1;;) {
                auto [found, idx] = find_first_of(source_.str, source_.len, start);
                if (found == str::npos) {
                    break;
                }
                if (search_results_.count_ < max_store) {
                    search_results_.replaces_[search_results_.count_] = {found, idx};
                }
                l += replaces_[idx].second.len - 1;
                search_results_.count_++;
                start = found + 1;
            }
        }
        return l;
    }
    K* place(K* ptr) const noexcept {
        size_t start = 0;
        const K* text = source_.str;
        if constexpr (UseVectorForReplace) {
            for (const auto& [pos, num] : search_results_) {
                size_t delta = pos - start;
                ch_traits<K>::copy(ptr, text + start, delta);
                ptr += delta;
                ptr = replaces_[num].second.place(ptr);
                start = pos + 1;
            }
        } else {
            const size_t max_store = std::size(search_results_.replaces_);
            size_t founded = search_results_.count_;
            for (size_t idx = 0, stop = std::min(founded, max_store); idx < stop; idx++) {
                const auto [pos, num] = search_results_.replaces_[idx];
                size_t delta = pos - start;
                ch_traits<K>::copy(ptr, text + start, delta);
                ptr += delta;
                ptr = replaces_[num].second.place(ptr);
                start = pos + 1;
            }
            if (founded > max_store) {
                founded  -= max_store;
                while (founded--) {
                    auto [fnd, idx] = find_first_of(source_.str, source_.len, start);
                    size_t delta = fnd - start;
                    ch_traits<K>::copy(ptr, text + start, delta);
                    ptr += delta;
                    ptr = replaces_[idx].second.place(ptr);
                    start = fnd + 1;
                }
            }
        }
        size_t tail = source_.len - start;
        ch_traits<K>::copy(ptr, text + start, tail);
        return ptr + tail;
    }
 
protected:
    size_t index_of(K s) const {
        return pattern_.find(s);
    }
 
    bool is_in_mask(uu8s s) const {
        return (bit_mask_[s >> 3] & (1 << (s & 7))) != 0;
    }
    bool is_in_mask2(uu8s s) const {
        return (bit_mask_[32 + (s >> 3)] & (1 << (s & 7))) != 0;
    }
 
    bool is_in_pattern(K s, size_t& idx) const {
        if constexpr (sizeof(K) == 1) {
            if (is_in_mask(s)) {
                idx = index_of(s);
                return true;
            }
        } else {
            if (std::make_unsigned_t<const K>(s) > 255) {
                if (is_in_mask2(s)) {
                    return (idx = index_of(s)) != -1;
                }
            } else {
                if (is_in_mask(s)) {
                    idx = index_of(s);
                    return true;
                }
            }
        }
        return false;
    }
 
    std::pair<size_t, size_t> find_first_of(const K* text, size_t len,  size_t offset = 0) const {
        size_t pl = pattern_.length();
        if  (pl >= BIT_SEARCH_TRESHHOLD) {
            size_t idx;
            while (offset < len) {
                if (is_in_pattern(text[offset], idx)) {
                    return {offset, idx};
                }
                offset++;
            }
        } else {
            while (offset < len) {
                if (size_t idx = index_of(text[offset]); idx != -1) {
                    return {offset, idx};
                }
                offset++;
            }
        }
        return {-1, -1};
    }
};
 
template<typename K, StrExprForType<K> T>
struct force_copy {
    const T& t_;
    force_copy(const T& t) : t_(t){}
};
 
template<typename K, typename T>
struct symb_type_from_src<force_copy<K, T>> {
    using type = K;
};
 
 
template<StrExpr T>
force_copy(T&&) -> force_copy<typename T::symb_type, T>;
 
template<typename K, typename T>
constexpr auto to_subst(T&& t) {
    return to_strexpr<K>(std::forward<T>(t));
}
 
template<typename K, typename T, size_t N>
constexpr auto to_subst(const T(&t)[N]) {
    return expr_literal<T, N - 1>{t};
}
 
template<typename K, StrExprForType<K> T>
constexpr decltype(auto) to_subst(T&& t) {
    return std::forward<T>(t);
}
 
template<typename K, typename T>
constexpr T to_subst(const force_copy<K, T>& t) {
    return t.t_;
}
 
template<typename K, typename T>
constexpr T to_subst(force_copy<K, T>&& t) {
    return t.t_;
}
 
template<typename K, typename T>
constexpr T to_subst(force_copy<K, T>& t) {
    return t.t_;
}
 
template<typename K, typename T>
using to_str_exp_t = decltype(to_subst<K>(std::declval<T>()));

template<typename K, typename G, typename Arg, typename...Args>
struct e_concat : expr_to_std_string<e_concat<K, G, Arg, Args...>> {
    using symb_type = K;
    using store_t = std::tuple<to_str_exp_t<K, Args>...>;
    using arg_t = to_str_exp_t<K, Arg>;
    to_str_exp_t<K, G> glue_;
    arg_t arg_;
    store_t args_;
    mutable size_t glue_len_;
    constexpr e_concat(G&& glue, Arg&& arg, Args&&...args)
        : glue_(to_subst<K>(std::forward<G>(glue)))
        , arg_(to_subst<K>(std::forward<Arg>(arg)))
        , args_(to_subst<K>(std::forward<Args>(args))...) {}
 
    constexpr size_t length() const noexcept {
        return [this]<size_t...Indexes>(std::index_sequence<Indexes...>) {
            glue_len_ = glue_.length();
            size_t l = arg_.length() + glue_len_ * sizeof...(Args);
            ((l += std::get<Indexes>(args_).length()),...);
            return l;
        }(std::make_index_sequence<sizeof...(Args)>());
    }
    constexpr K* place(K* ptr) const noexcept {
        return [this]<size_t...Indexes>(K* ptr, std::index_sequence<Indexes...>) {
            ptr = (K*)arg_.place((typename std::remove_cvref_t<arg_t>::symb_type*)ptr);
            const K* glueStart = ptr;
            ptr = glue_.place(ptr);
            (
                (
                    ptr = (K*)std::get<Indexes>(args_).place((typename std::remove_cvref_t<std::tuple_element_t<Indexes, store_t>>::symb_type*)ptr),
                    glue_len_ > 0 && Indexes < sizeof...(Args) - 1 ? (ch_traits<K>::copy(ptr, glueStart, glue_len_), ptr += glue_len_) : nullptr
                ),
            ...);
            return ptr;
        }(ptr, std::make_index_sequence<sizeof...(Args)>());
    }
};
// CTAD deducing rule for e_concat
template<typename T, typename ... Args> requires (sizeof...(Args) > 1)
e_concat(T&&, Args&&...) -> e_concat<symb_type_from_src_t<T>, T, Args...>;
 
struct parse_subst_string_error {
    parse_subst_string_error(const char*){}
};
 
namespace details {
 
template<typename K, size_t NParams>
constexpr size_t parse_pattern_string(str_src<K> pattern, auto&& add_part, auto&& add_param) {
    char used_args[NParams] = {0};
    const K* first = pattern.begin(), *last = pattern.end(), *start = first;
    size_t all_len = 0;
 
    auto find = [](const K* from, const K* last, K s) {
        while (from != last) {
            if (*from == s) {
                break;
            }
            from++;
        }
        return from;
    };
    size_t idx_in_params = 0;
 
    while (first != last) {
        const K* open_pos = first;
        if (*first != '{') {
            open_pos = find(first, last, '{');
 
            for (;;) {
                const K* close_pos = find(first, open_pos, '}');
                if (close_pos == open_pos) {
                    unsigned len = open_pos - first;
                    add_part(first - start, len);
                    all_len += len;
                    break;
                }
                ++close_pos;
                if (close_pos == open_pos || *close_pos != '}') {
                    throw parse_subst_string_error{"unescaped }"};
                }
                unsigned len = close_pos - first;
                add_part(first - start, len);
                all_len += len;
                first = ++close_pos;
            }
            if (open_pos == last) {
                break;
            }
        }
        if (++open_pos == last) {
            throw parse_subst_string_error{"unescaped {"};
        }
        if (*open_pos == '}') {
            if (idx_in_params == -1) {
                throw parse_subst_string_error{"already used param ids"};
            }
            if (idx_in_params == NParams) {
                throw parse_subst_string_error{"too many params"};
            }
            used_args[idx_in_params] = 1;
            add_param(idx_in_params++);
            first = open_pos + 1;
        } else if (*open_pos == '{') {
            add_part(open_pos - start, 1);
            all_len++;
            first = open_pos + 1;
        } else {
            if (idx_in_params != 0 && idx_in_params != -1) {
                throw parse_subst_string_error{"already used non id params"};
            }
            idx_in_params = -1;
            const K* end = find(open_pos, last, '}');
            if (end == last) {
                throw parse_subst_string_error{"not found }"};
            }
            auto [p, err, _] = str_src<K>(open_pos, end - open_pos).template to_int<unsigned, true, 10, false, false>();
            if (err != IntConvertResult::Success || p < 1 || p > NParams) {
                throw parse_subst_string_error{"bad param id"};
            }
            used_args[--p] = 1;
            add_param(p);
            first = end + 1;
        }
    }
    for (auto c : used_args) {
        if (!c) {
            throw parse_subst_string_error{"unused param"};
        }
    }
    return all_len;
}
 
struct portion {
    unsigned start: 16;
    unsigned len: 15;
    unsigned is_param: 1;
 
    portion() = default;
 
    constexpr void set_param(unsigned param) {
        if (param >= (1 << 16)) {
            throw parse_subst_string_error{"the parameter id is too large"};
        }
        start = param;
        is_param = 1;
    }
    constexpr void set_part(unsigned from, unsigned l) {
        if (from >= (1 << 16) || l >= (1 << 15)) {
            throw parse_subst_string_error{"the string part is too large"};
        }
        start = from;
        len = l;
        is_param = 0;
    }
};
 
template<typename K, size_t PtLen, size_t NParams>
struct subst_params {
    const K(&source_)[PtLen];
    unsigned all_len_{};
    unsigned actual_{};
    // The pattern string can be divided into a maximum of this number of portions.
    // "a{}a{}a{}a" - One portion of one symbol from the edge, and two portions for every three symbols
    portion portions_[1 + ((PtLen - 2) * 2 / 3)]{};
 
    consteval subst_params(const K(&pattern)[PtLen]) : source_(pattern) {
        all_len_ = parse_pattern_string<K, NParams>(pattern,
            [this](unsigned from, unsigned len) {
                portions_[actual_++].set_part(from, len);
            }, [this](unsigned param) {
                portions_[actual_++].set_param(param);
            });
    }
};
 
} // namespace details

template<typename K, size_t PtLen, typename ... Args>
struct e_subst : expr_to_std_string<e_subst<K, PtLen, Args...>> {
    inline static constexpr size_t NParams = sizeof...(Args);
    using symb_type = K;
    using store_t = std::tuple<to_str_exp_t<K, Args>...>;
 
    const details::subst_params<K, PtLen, NParams>& subst_;
    store_t args_;
    constexpr e_subst(const details::subst_params<K, PtLen, NParams>& subst, Args&&...args)
        : subst_(subst)
        , args_(to_subst<K>(std::forward<Args>(args))...){}
 
    constexpr size_t length() const noexcept {
        return [this]<size_t...Indexes>(std::index_sequence<Indexes...>) {
            size_t idx = 0;
            size_t expr_length_[NParams] = {};
            ((expr_length_[idx++] = std::get<Indexes>(args_).length()),...);
            size_t l = subst_.all_len_;
            for (idx = 0; idx < subst_.actual_; idx++) {
                if (subst_.portions_[idx].is_param) {
                    l += expr_length_[subst_.portions_[idx].start];
                }
            }
            return l;
        }(std::make_index_sequence<sizeof...(Args)>());
    }
    template<size_t Idx>
    constexpr K* place_idx(K* ptr, size_t idx) const noexcept {
        if (idx == Idx) {
            return (K*)std::get<Idx>(args_).place((typename std::remove_cvref_t<std::tuple_element_t<Idx, store_t>>::symb_type*)ptr);
        }
        if constexpr (Idx < NParams - 1) {
            return place_idx<Idx + 1>(ptr, idx);
        }
        return ptr;
    }
    constexpr K* place(K* ptr) const noexcept {
        for (size_t idx = 0; idx < subst_.actual_; idx++) {
            if (subst_.portions_[idx].is_param) {
                ptr = place_idx<0>(ptr, subst_.portions_[idx].start);
            } else {
                ch_traits<K>::copy(ptr, subst_.source_ + subst_.portions_[idx].start, subst_.portions_[idx].len);
                ptr += subst_.portions_[idx].len;
            }
        }
        return ptr;
    }
};
 
// CTAD deducing rule for e_subst
template<typename K, size_t N, typename...Args> requires (sizeof...(Args) > 0)
e_subst(const K(&)[N], Args&&...) -> e_subst<K, N, Args...>;

template<typename K, typename ... Args>
struct e_vsubst : expr_to_std_string<e_vsubst<K, Args...>> {
    inline static constexpr size_t Nparams = sizeof...(Args);
    using symb_type = K;
    using store_t = std::tuple<to_str_exp_t<K, Args>...>;
 
    details::portion portions_[Nparams * 3];
    std::vector<details::portion> more_portions_;
    store_t args_;
    str_src<K> pattern_;
    size_t all_len_{};
    unsigned actual_{};
    constexpr e_vsubst(str_src<K> pattern, Args&&...args)
        : pattern_(pattern)
        , args_(to_subst<K>(std::forward<Args>(args))...) {
 
        all_len_ = details::parse_pattern_string<K, Nparams>(pattern_, [this](unsigned from, unsigned len) {
                if (actual_ < std::size(portions_)) {
                    portions_[actual_++].set_part(from, len);
                } else {
                    if (actual_ == std::size(portions_)) {
                        more_portions_.reserve((pattern_.len - 1) * 2 / 3 - std::size(portions_));
                    }
                    more_portions_.emplace_back().set_part(from, len);
                }
            }, [this](unsigned param) {
                if (actual_ < std::size(portions_)) {
                    portions_[actual_++].set_param(param);
                } else {
                    if (actual_ == std::size(portions_)) {
                        more_portions_.reserve((pattern_.len - 1) * 2 / 3 - std::size(portions_));
                    }
                    more_portions_.emplace_back().set_param(param);
                }
            }
        );
    }
    constexpr size_t length() const noexcept {
        return [this]<size_t...Indexes>(std::index_sequence<Indexes...>) {
            size_t idx = 0;
            size_t expr_length_[Nparams] = {};
            ((expr_length_[idx++] = std::get<Indexes>(args_).length()),...);
            size_t l = all_len_;
            for (idx = 0; idx < actual_; idx++) {
                if (portions_[idx].is_param) {
                    l += expr_length_[portions_[idx].start];
                }
            }
            for (const auto& p : more_portions_) {
                if (p.is_param) {
                    l += expr_length_[p.start];
                }
            }
            return l;
        }(std::make_index_sequence<sizeof...(Args)>());
    }
    template<size_t Idx>
    constexpr K* place_idx(K* ptr, size_t idx) const noexcept {
        if (idx == Idx) {
            return (K*)std::get<Idx>(args_).place((typename std::remove_cvref_t<std::tuple_element_t<Idx, store_t>>::symb_type*)ptr);
        }
        if constexpr (Idx < Nparams - 1) {
            return place_idx<Idx + 1>(ptr, idx);
        }
        return ptr;
    }
    constexpr K* place(K* ptr) const noexcept {
        for (size_t idx = 0; idx < actual_; idx++) {
            if (portions_[idx].is_param) {
                ptr = place_idx<0>(ptr, portions_[idx].start);
            } else {
                ch_traits<K>::copy(ptr, pattern_.symbols() + portions_[idx].start, portions_[idx].len);
                ptr += portions_[idx].len;
            }
        }
        for (const auto& p : more_portions_) {
            if (p.is_param) {
                ptr = place_idx<0>(ptr, p.start);
            } else {
                const K* from = pattern_.symbols() + p.start;
                for (size_t idx = p.len; idx--;) {
                    *ptr++ = *from++;
                }
                //ch_traits<K>::copy(ptr, pattern_.symbols() + p.start, p.len);
                //ptr += p.len;
            }
        }
        return ptr;
    }
};
// CTAD deducing rule for e_vsubst
template<StrSourceNoLiteral T, typename...Args> requires (sizeof...(Args) > 0)
e_vsubst(T&&, Args&&...) -> e_vsubst<symb_type_from_src_t<T>, Args...>;
 
template<is_one_of_char_v K, bool upper>
struct expr_change_case_ascii : expr_to_std_string<expr_change_case_ascii<K, upper>>{
    using symb_type = K;
 
    str_src<K> src_;
 
    template<StrSource S>
    expr_change_case_ascii(S&& s) : src_(std::forward<S>(s)){}
 
    constexpr size_t length() const noexcept {
        return src_.length();
    }
    constexpr K* place(K* ptr) const noexcept {
        const K* read = src_.str;
        for (size_t l = src_.len; l--;) {
            if constexpr (upper) {
                *ptr++ = makeAsciiUpper(*read++);
            } else {
                *ptr++ = makeAsciiLower(*read++);
            }
        }
        return ptr;
    }
};

template<is_one_of_char_v K>
struct e_ascii_upper : expr_change_case_ascii<K, true> {
    using base = expr_change_case_ascii<K, true>;
    using base::base;
};
 
template<StrSource S>
e_ascii_upper(S&&) -> e_ascii_upper<symb_type_from_src_t<S>>;

template<is_one_of_char_v K>
struct e_ascii_lower : expr_change_case_ascii<K, false> {
    using base = expr_change_case_ascii<K, false>;
    using base::base;
};
 
template<StrSource S>
e_ascii_lower(S&&) -> e_ascii_lower<symb_type_from_src_t<S>>;

namespace str {

template<typename K, typename A, StrExprForType<K> E>
std::basic_string<K, std::char_traits<K>, A>& change(std::basic_string<K, std::char_traits<K>, A>& str, size_t from, size_t count, const E& expr) {
    size_t expr_length = expr.length();
    if (!expr_length) {
        str.erase(from, count);
        return str;
    }
    size_t str_length = str.length();
    if (from > str_length) {
        from = str_length;
    }
    if (count > str_length || from + count > str_length) {
        count = str_length - from;
    }
    size_t new_length = str_length - count + expr_length;
    size_t tail_length = str_length - count - from;
 
    if (new_length <= str_length) {
        K* data = str.data();
        expr.place((typename E::symb_type*)data + from);
        if (expr_length < count) {
            if (tail_length) {
                std::char_traits<K>::move(data + from + expr_length, data + from + count, tail_length);
            }
            str.resize(new_length);
        }
    } else {
        auto fill = [&](K* data, size_t) -> size_t {
            if (tail_length) {
                std::char_traits<K>::move(data + from + expr_length, data + from + count, tail_length);
            }
            expr.place((typename E::symb_type*)data + from);
            return new_length;
        };
        if constexpr (requires{str.resize_and_overwrite(new_length, fill);}) {
            str.resize_and_overwrite(new_length, fill);
        } else if constexpr (requires{str._Resize_and_overwrite(new_length, fill);}) {
            str._Resize_and_overwrite(new_length, fill);
        } else {
            str.resize(new_length);
            fill(str.data(), 0);
        }
    }
    return str;
}

template<typename K, typename A, StrExprForType<K> E>
std::basic_string<K, std::char_traits<K>, A>& append(std::basic_string<K, std::char_traits<K>, A>& str, const E& expr) {
    return change(str, str.length(), 0, expr);
}

template<typename K, typename A, StrExprForType<K> E>
std::basic_string<K, std::char_traits<K>, A>& prepend(std::basic_string<K, std::char_traits<K>, A>& str, const E& expr) {
    return change(str, 0, 0, expr);
}

template<typename K, typename A, StrExprForType<K> E>
std::basic_string<K, std::char_traits<K>, A>& insert(std::basic_string<K, std::char_traits<K>, A>& str, size_t from, const E& expr) {
    return change(str, from, 0, expr);
}

template<typename K, typename A, StrExprForType<K> E>
std::basic_string<K, std::char_traits<K>, A>& overwrite(std::basic_string<K, std::char_traits<K>, A>& str, const E& expr) {
    if (size_t expr_length = expr.length()) {
        if (expr_length <= str.length()) {
            K* data = str.data();
            expr.place((typename E::symb_type*)data);
            str.resize(expr_length);
        } else {
            auto fill = [&](K* data, size_t) -> size_t {
                expr.place((typename E::symb_type*)data);
                return expr_length;
            };
            if constexpr (requires{str.resize_and_overwrite(expr_length, fill);}) {
                str.resize_and_overwrite(expr_length, fill);
            } else if constexpr (requires{str._Resize_and_overwrite(expr_length, fill);}) {
                str._Resize_and_overwrite(expr_length, fill);
            } else {
                str.resize(expr_length);
                expr.place((typename E::symb_type*)str.data());
            }
        }
    } else {
        str.clear();
    }
    return str;
}
 
namespace details {
 
template<typename K, typename A, typename E>
struct replace_grow_helper {
    using my_type = std::basic_string<K, std::char_traits<K>, A>;
 
    replace_grow_helper(my_type& src, str_src<K> p, const K* r, size_t rl, size_t mc, size_t d, const E& e)
        : str(src), source(src), pattern(p), repl(const_cast<K*>(r)), replLen(rl), maxCount(mc), delta(d), expr(e) {}
    my_type& str;
 
    const str_src<K> source;
    const str_src<K> pattern;
    K* repl;
    const size_t replLen;
 
    size_t maxCount;
    const size_t delta;
    size_t all_delta{};
    const E& expr;
 
    K* reserve_for_copy{};
    size_t end_of_piece{};
    size_t total_length{};
 
    std::optional<my_type> dst;
 
    void replace(size_t offset) {
        size_t found[16] = {offset};
        maxCount--;
 
        offset += pattern.len;
        all_delta += delta;
        size_t idx = 1;
        for (; idx < std::size(found) && maxCount > 0; idx++, maxCount--) {
            found[idx] = source.find(pattern, offset);
            if (found[idx] == npos) {
                break;
            }
            offset = found[idx] + pattern.len;
            all_delta += delta;
        }
        if (idx == std::size(found) && maxCount > 0 && (offset = source.find(pattern, offset)) != str::npos) {
            replace(offset); // здесь произойдут замены в оставшемся хвосте | replacements will be made here in the remaining tail
        }
        // Теперь делаем свои замены
        // Now we make our replacements
        if (!reserve_for_copy) {
            // Только начинаем
            // Just getting started
            end_of_piece = source.length();
            total_length = end_of_piece + all_delta;
            my_type* dst_str{};
            if (total_length <= str.capacity()) {
                // Строка поместится в старое место | The string will be placed in the old location.
                dst_str = &str;
            } else {
                // Будем создавать в другом буфере | We will create in another buffer.
                dst_str = &dst.emplace();
            }
            auto fill = [this](K* p, size_t) -> size_t {
                reserve_for_copy = p;
                return total_length;
            };
            if constexpr (requires{dst_str->_Resize_and_overwrite(total_length, fill);}) {
                dst_str->_Resize_and_overwrite(total_length, fill);
            } else if constexpr (requires{dst_str->resize_and_overwrite(total_length, fill);}) {
                dst_str->resize_and_overwrite(total_length, fill);
            } else {
                dst_str->resize(total_length);
                reserve_for_copy = dst_str->data();
            }
        }
        const K* src_start = str.c_str();
        while(idx-- > 0) {
            size_t pos = found[idx] + pattern.len;
            size_t lenOfPiece = end_of_piece - pos;
            ch_traits<K>::move(reserve_for_copy + pos + all_delta, src_start + pos, lenOfPiece);
            if constexpr (std::is_same_v<E, int>) {
                ch_traits<K>::copy(reserve_for_copy + pos + all_delta - replLen, repl, replLen);
            } else {
                if (!repl) {
                    repl = reserve_for_copy + pos + all_delta - replLen;
                    expr.place(repl);
                } else {
                    ch_traits<K>::copy(reserve_for_copy + pos + all_delta - replLen, repl, replLen);
                }
            }
            all_delta -= delta;
            end_of_piece = found[idx];
        }
        if (!all_delta && reserve_for_copy != src_start) {
            ch_traits<K>::copy(reserve_for_copy, src_start, found[0]);
            str = std::move(*dst);
        }
    }
};
 
} // namespace details

template<typename K, typename A, StrExprForType<K> E, typename T>
requires (std::is_constructible_v<str_src<K>, T>)
std::basic_string<K, std::char_traits<K>, A>& replace(std::basic_string<K, std::char_traits<K>, A>& str, T&& pattern, const E& repl, size_t offset = 0, size_t max_count = -1) {
    if (!max_count) {
        return str;
    }
    str_src<K> src = str;
    str_src<K> spattern{std::forward<T>(pattern)};
    offset = src.find(pattern, offset);
    if (offset == npos) {
        return str;
    }
    size_t replLen = repl.length();
    K* replStart{};
    if (spattern.len == replLen) {
        // Заменяем inplace на подстроку такой же длины
        // Replace inplace with a substring of the same length
        K* ptr = str.data();
        replStart = ptr + offset;
        repl.place(replStart);
 
        while (--max_count) {
            offset = src.find(spattern, offset + replLen);
            if (offset == npos)
                break;
            ch_traits<K>::copy(ptr + offset, replStart, replLen);
        }
    } else if (spattern.len > replLen) {
        // Заменяем на более короткий кусок, длина текста уменьшится, идём слева направо
        // Replace with a shorter piece, the length of the text will decrease, go from left to right
        K* ptr = str.data();
        replStart = ptr + offset;
        repl.place(replStart);
        size_t posWrite = offset + replLen;
        offset += spattern.len;
 
        while (--max_count) {
            size_t idx = src.find(spattern, offset);
            if (idx == npos)
                break;
            size_t lenOfPiece = idx - offset;
            ch_traits<K>::move(ptr + posWrite, ptr + offset, lenOfPiece);
            posWrite += lenOfPiece;
            ch_traits<K>::copy(ptr + posWrite, replStart, replLen);
            posWrite += replLen;
            offset = idx + spattern.len;
        }
        size_t tailLen = src.len - offset;
        ch_traits<K>::move(ptr + posWrite, ptr + offset, tailLen);
        str.resize(posWrite + tailLen);
    } else {
        details::replace_grow_helper<K, A, E>(str, spattern, nullptr, replLen, max_count, replLen - spattern.len, repl).replace(offset);
    }
    return str;
}

template<typename K, typename A>
std::basic_string<K, std::char_traits<K>, A>& replace(std::basic_string<K, std::char_traits<K>, A>& str, str_src<K> pattern, str_src<K> repl, size_t offset = 0, size_t max_count = -1) {
    if (!max_count) {
        return str;
    }
    str_src<K> src = str;
    offset = src.find(pattern, offset);
    if (offset == npos) {
        return str;
    }
    if (pattern.len == repl.len) {
        // Заменяем inplace на подстроку такой же длины
        // Replace inplace with a substring of the same length
        K* ptr = str.data();
        while (max_count--) {
            ch_traits<K>::copy(ptr + offset, repl.str, repl.len);
            offset = src.find(pattern, offset + repl.len);
            if (offset == npos)
                break;
        }
    } else if (pattern.len > repl.len) {
        // Заменяем на более короткий кусок, длина текста уменьшится, идём слева направо
        // Replace with a shorter piece, the length of the text will decrease, go from left to right
        K* ptr = str.data();
        ch_traits<K>::copy(ptr + offset, repl.str, repl.len);
        size_t posWrite = offset + repl.len;
        offset += pattern.len;
 
        while (--max_count) {
            size_t idx = src.find(pattern, offset);
            if (idx == npos)
                break;
            size_t lenOfPiece = idx - offset;
            ch_traits<K>::move(ptr + posWrite, ptr + offset, lenOfPiece);
            posWrite += lenOfPiece;
            ch_traits<K>::copy(ptr + posWrite, repl.str, repl.len);
            posWrite += repl.len;
            offset = idx + pattern.len;
        }
        size_t tailLen = src.len - offset;
        ch_traits<K>::move(ptr + posWrite, ptr + offset, tailLen);
        str.resize(posWrite + tailLen);
    } else {
        details::replace_grow_helper<K, A, int>(str, pattern, repl.str, repl.len, max_count, repl.len - pattern.len, 0).replace(offset);
    }
    return str;
}
 
template<typename K, typename A, typename T, typename M>
requires (std::is_constructible_v<str_src<K>, T> && std::is_constructible_v<str_src<K>, M>)
std::basic_string<K, std::char_traits<K>, A>& replace(std::basic_string<K, std::char_traits<K>, A>& str, T&& pattern, M&& repl, size_t offset = 0, size_t max_count = -1) {
    return replace(str, str_src<K>{std::forward<T>(pattern)}, str_src<K>{std::forward<M>(repl)}, offset, max_count);
}

template<typename K, typename A>
std::basic_string<K, std::char_traits<K>, A>& make_ascii_upper(std::basic_string<K, std::char_traits<K>, A>& str, size_t from = 0, size_t to = -1) {
    for (K *ptr = str.data() + std::min(from, str.length()), *end = str.data() + std::min(to, str.length()); ptr < end; ptr++) {
        K s = *ptr;
        if (isAsciiLower(s)) {
            *ptr = s & ~0x20;
        }
    }
    return str;
}

template<typename K, typename A>
std::basic_string<K, std::char_traits<K>, A>& make_ascii_lower(std::basic_string<K, std::char_traits<K>, A>& str, size_t from = 0, size_t to = -1) {
    for (K *ptr = str.data() + std::min(from, str.length()), *end = str.data() + std::min(to, str.length()); ptr < end; ptr++) {
        K s = *ptr;
        if (isAsciiUpper(s)) {
            *ptr = s | 0x20;
        }
    }
    return str;
}
 
} // namespace str
 
} // namespace simstr

namespace std {
template<simstr::StdStrSource T>
simstr::expr_stdstr<typename T::value_type, T> operator+(const T& str) {
    return {str};
}

template<typename K, typename A, simstr::StrExprForType<K> E>
std::basic_string<K, std::char_traits<K>, A>& operator |=(std::basic_string<K, std::char_traits<K>, A>& str, const E& expr) {
    return simstr::str::change(str, str.length(), 0, expr);
}

template<typename K, typename A, simstr::StrExprForType<K> E>
std::basic_string<K, std::char_traits<K>, A>& operator ^=(std::basic_string<K, std::char_traits<K>, A>& str, const E& expr) {
    return simstr::str::change(str, 0, 0, expr);
}
 
} // namespace std