#ifndef CPP2_CPP2UTIL_H

#define CPP2_CPP2UTIL_H

#include <version>

#undef CPP2_USE_SOURCE_LOCATION

#if defined(__cpp_lib_source_location)

#define CPP2_USE_SOURCE_LOCATION Yes

#endif

#if defined(CPP2_IMPORT_STD) || defined(CPP2_INCLUDE_STD)

// If C++23 'import std;' was requested but isn't available, fall back

// to the 'include std' path

#if defined(CPP2_IMPORT_STD) && defined(__cpp_lib_modules)

import std.compat;

// If 'include std' was requested, include all standard headers.

// This list tracks the current draft standard, so as of this

// writing includes draft C++26 headers like <debugging>.

// Use a feature test #ifdef for each header that isn't supported

// by all of { VS 2022, g++-10, clang++-12 }

#else

#ifdef _MSC_VER

#include "intrin.h"

#endif

#include <algorithm>

#include <any>

#include <array>

#include <atomic>

#ifdef __cpp_lib_barrier

#include <barrier>

#endif

#include <bit>

#include <bitset>

#include <cassert>

#include <cctype>

#include <cerrno>

#include <cfenv>

#include <cfloat>

#include <charconv>

#include <chrono>

#include <cinttypes>

#include <climits>

#include <clocale>

#include <cmath>

#include <codecvt>

#include <compare>

#include <complex>

#include <concepts>

#include <condition_variable>

#ifdef __cpp_lib_coroutine

#include <coroutine>

#endif

#include <csetjmp>

#include <csignal>

#include <cstdarg>

#include <cstddef>

#include <cstdint>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <ctime>

#if __has_include(<cuchar>)

#include <cuchar>

#endif

#include <cwchar>

#include <cwctype>

#ifdef __cpp_lib_debugging

#include <debugging>

#endif

#include <deque>

#ifndef CPP2_NO_EXCEPTIONS

#include <exception>

#endif

// libstdc++ currently has a dependency on linking TBB if <execution> is

// included, and TBB seems to be not automatically installed and linkable

// on some GCC installations, so let's not pull in that little-used header

// in our -pure-cpp2 "import std;" simulation mode... if you need this,

// use mixed mode (not -pure-cpp2) and #include all the headers you need

// including this one

//

// #include <execution>

#ifdef __cpp_lib_expected

#include <expected>

#endif

#include <filesystem>

#if defined(__cpp_lib_format) || (defined(_MSC_VER) && _MSC_VER >= 1929)

#include <format>

#endif

#ifdef __cpp_lib_flat_map

#include <flat_map>

#endif

#ifdef __cpp_lib_flat_set

#include <flat_set>

#endif

#include <forward_list>

#include <fstream>

#include <functional>

#include <future>

#ifdef __cpp_lib_generator

#include <generator>

#endif

#ifdef __cpp_lib_hazard_pointer

#include <hazard_pointer>

#endif

#include <initializer_list>

#ifdef __cpp_lib_inplace_vector

#include <inplace_vector>

#endif

#include <iomanip>

#include <ios>

#include <iosfwd>

#include <iostream>

#include <iso646.h>

#include <istream>

#include <iterator>

#ifdef __cpp_lib_latch

#include <latch>

#endif

#include <limits>

#ifdef __cpp_lib_linalg

#include <linalg>

#endif

#include <list>

#include <locale>

#include <map>

#ifdef __cpp_lib_mdspan

#include <mdspan>

#endif

#include <memory>

#ifdef __cpp_lib_memory_resource

#include <memory_resource>

#endif

#include <mutex>

#include <new>

#include <numbers>

#include <numeric>

#include <optional>

#include <ostream>

#ifdef __cpp_lib_print

#include <print>

#endif

#include <queue>

#include <random>

#include <ranges>

#include <ratio>

#ifdef __cpp_lib_rcu

#include <rcu>

#endif

#include <regex>

#include <scoped_allocator>

#ifdef __cpp_lib_semaphore

#include <semaphore>

#endif

#include <set>

#include <shared_mutex>

#ifdef __cpp_lib_source_location

#include <source_location>

#endif

#include <span>

#ifdef __cpp_lib_spanstream

#include <spanstream>

#endif

#include <sstream>

#include <stack>

#ifdef __cpp_lib_stacktrace

#include <stacktrace>

#endif

#ifdef __cpp_lib_stdatomic_h

#include <stdatomic.h>

#endif

#include <stdexcept>

#if __has_include(<stdfloat>)

#if !defined(_MSC_VER) || _HAS_CXX23

#include <stdfloat>

#endif

#endif

#ifdef __cpp_lib_jthread

#include <stop_token>

#endif

#include <streambuf>

#include <string>

#include <string_view>

#ifdef __cpp_lib_syncbuf

#include <syncstream>

#endif

#include <system_error>

#ifdef __cpp_lib_text_encoding

#include <text_encoding>

#endif

#include <thread>

#include <tuple>

#include <type_traits>

#include <typeindex>

#ifndef CPP2_NO_RTTI

#include <typeinfo>

#endif

#include <unordered_map>

#include <unordered_set>

#include <utility>

#include <valarray>

#include <variant>

#include <vector>

#endif

#else

#ifdef _MSC_VER

#include "intrin.h"

#endif

#include <algorithm>

#include <any>

#include <compare>

#include <concepts>

#include <cstddef>

#include <cstdint>

#include <cstdio>

#ifndef CPP2_NO_EXCEPTIONS

#include <exception>

#endif

#ifdef __cpp_lib_expected

#include <expected>

#endif

#if defined(__cpp_lib_format) || (defined(_MSC_VER) && _MSC_VER >= 1929)

#include <format>

#endif

#include <functional>

#include <iostream>

#include <sstream>

#include <iterator>

#include <limits>

#include <map>

#include <memory>

#include <numeric>

#include <new>

#include <random>

#include <optional>

#if defined(CPP2_USE_SOURCE_LOCATION)

#include <source_location>

#endif

#include <ranges>

#include <set>

#include <span>

#include <sstream>

#include <string>

#include <string_view>

#include <system_error>

#include <tuple>

#include <type_traits>

#ifndef CPP2_NO_RTTI

#include <typeinfo>

#endif

#include <utility>

#include <variant>

#include <vector>

#endif

#ifdef __clang__

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wsign-conversion"

#endif

#define CPP2_TYPEOF(x) std::remove_cvref_t<decltype(x)>

#if __cplusplus >= 202302L && \

( \

(defined(__clang_major__) && __clang_major__ >= 15) \

|| (defined(__GNUC__) && __GNUC__ >= 12) \

)

#define CPP2_COPY(x) auto(x)

#else

#define CPP2_COPY(x) CPP2_TYPEOF(x)(x)

#endif

#define CPP2_FORWARD(x) std::forward<decltype(x)>(x)

#define CPP2_PACK_EMPTY(x) (sizeof...(x) == 0)

#define CPP2_CONTINUE_BREAK(NAME) goto CONTINUE_##NAME; CONTINUE_##NAME: continue; goto BREAK_##NAME; BREAK_##NAME: break;

// these redundant goto's to avoid 'unused label' warnings

#if defined(__clang_major__)

constexpr auto gcc_ver = 0;

constexpr auto clang_ver = __clang_major__ * 100 + __clang_minor__;

constexpr auto msvc_ver = 0;

#elif defined(_MSC_VER)

constexpr auto gcc_ver = 0;

constexpr auto clang_ver = 0;

constexpr auto msvc_ver = _MSC_VER;

#elif defined(__GNUC__)

constexpr auto gcc_ver = __GNUC__ * 100 + __GNUC_MINOR__;

constexpr auto clang_ver = 0;

constexpr auto msvc_ver = 0;

#endif

constexpr auto gcc_clang_msvc_min_versions(

}

#if defined(_MSC_VER)

// MSVC can't handle 'inline constexpr' yet in all cases

#define CPP2_CONSTEXPR const

#else

#define CPP2_CONSTEXPR constexpr

#endif

namespace cpp2 {

using i8 = std::int8_t ;

using i16 = std::int16_t ;

using i32 = std::int32_t ;

using i64 = std::int64_t ;

using u8 = std::uint8_t ;

using u16 = std::uint16_t ;

using u32 = std::uint32_t ;

using u64 = std::uint64_t ;

using ushort = unsigned short;

using uint = unsigned int;

using ulong = unsigned long;

using longlong = long long;

using ulonglong = unsigned long long;

using longdouble = long double;

using _schar = signed char; // normally use i8 instead

using _uchar = unsigned char; // normally use u8 instead

namespace string_util {

auto split_string_list(std::string_view str)

}

inline void ltrim(std::string &s) {

}

inline void rtrim(std::string &s) {

}

inline void trim(std::string &s) {

rtrim(s);

ltrim(s);

}

inline std::string trim_copy(std::string_view s) {

}

template<typename CharT, std::size_t N>

struct fixed_string {

};

template<typename CharT, std::size_t N>

fixed_string(const CharT (&)[N])->fixed_string<CharT, N-1>;

inline bool is_escaped(std::string_view s) {

}

inline bool string_to_int(std::string const& s, int& v, int base = 10) {

}

template<int Base = 10>

inline std::string int_to_string(int i) {

}

inline char safe_toupper(char ch) {

return static_cast<char>(std::toupper(static_cast<unsigned char>(ch)));

}

inline char safe_tolower(char ch) {

return static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));

}

inline std::string replace_all(

}

template<typename List>

inline std::string join(List const& list) {

}

} // namespace string_util

template <typename T>

using cpp1_ref = std::add_lvalue_reference_t<T>;

template <typename T>

using cpp1_rvalue_ref = std::add_rvalue_reference_t<T>;

template<typename Ret, typename Arg>

auto argument_of_helper(Ret(*) (Arg)) -> Arg;

template<typename Ret, typename F, typename Arg>

auto argument_of_helper(Ret(F::*) (Arg)) -> Arg;

template<typename Ret, typename F, typename Arg>

auto argument_of_helper(Ret(F::*) (Arg)&) -> Arg;

template<typename Ret, typename F, typename Arg>

auto argument_of_helper(Ret(F::*) (Arg)&&) -> Arg;

template<typename Ret, typename F, typename Arg>

auto argument_of_helper(Ret(F::*) (Arg) const) -> Arg;

template<typename Ret, typename F, typename Arg>

auto argument_of_helper(Ret(F::*) (Arg) const&) -> Arg;

template<typename Ret, typename F, typename Arg>

auto argument_of_helper(Ret(F::*) (Arg) const&&) -> Arg;

template <typename F>

auto argument_of_helper(F const&) -> CPP2_TYPEOF(argument_of_helper(&F::operator()));

template <typename T>

using argument_of_t = CPP2_TYPEOF(argument_of_helper(std::declval<T>()));

template <typename F>

auto argument_of_helper_op_is(F const&) -> CPP2_TYPEOF(argument_of_helper(&F::op_is));

template <typename T>

using argument_of_op_is_t = CPP2_TYPEOF(argument_of_helper_op_is(std::declval<T>()));

template <typename T>

using pointee_t = std::iter_value_t<T>;

template <template <typename...> class C, typename... Ts>

constexpr auto specialization_of_template_helper(C< Ts...> const& ) -> std::true_type {

return {};

}

template <template <typename, auto...> class C, typename T, auto... Ns>

requires (sizeof...(Ns) > 0)

constexpr auto specialization_of_template_helper(C< T, Ns... > const& ) -> std::true_type {

return {};

}

template <typename X, template<typename...> class C>

concept specialization_of_template = requires (X x) {

{ specialization_of_template_helper<C>(std::forward<X>(x)) } -> std::same_as<std::true_type>;

};

template <typename X, template<typename,auto...> class C>

concept specialization_of_template_type_and_nttp = requires (X x) {

{ specialization_of_template_helper<C>(std::forward<X>(x)) } -> std::same_as<std::true_type>;

};

template<typename X>

concept boolean_testable = std::convertible_to<X, bool> && requires(X&& x) {

{ !std::forward<X>(x) } -> std::convertible_to<bool>;

};

template <typename X>

concept dereferencable = requires (X x) { *x; };

template <typename X>

concept default_constructible = std::is_default_constructible_v<std::remove_cvref_t<X>>;

template <typename X>

concept bounded_array = std::is_bounded_array_v<std::remove_cvref_t<X>>;

template <typename X>

concept pointer_like = dereferencable<X> && default_constructible<X> && std::equality_comparable<X>

&& !bounded_array<X>;

template< typename From, typename To >

concept brace_initializable_to = requires (From x) { To{x}; };

template< typename X, typename C >

concept same_type_as = std::same_as<std::remove_cvref_t<X>, std::remove_cvref_t<C>>;

template <typename X>

concept defined = requires { std::declval<X>(); };

template <typename X>

concept has_defined_argument = requires {

std::declval<argument_of_t<X>>();

};

template <typename X, typename F>

concept covertible_to_argument_of = same_type_as<X,argument_of_t<F>>

|| (pointer_like<argument_of_t<F>> && brace_initializable_to<X, pointee_t<argument_of_t<F>>>)

|| (!pointer_like<argument_of_t<F>> && brace_initializable_to<X, argument_of_t<F>>)

;

template <typename F, typename X>

concept valid_predicate = (std::predicate<F, X> && !has_defined_argument<F>)

|| (std::predicate<F, X> && has_defined_argument<F> && covertible_to_argument_of<X, F>);

template <typename X, typename O, auto mem_fun_ptr>

concept predicate_member_fun = requires (X x, O o) {

{ (o.*mem_fun_ptr)(x) } -> std::convertible_to<bool>;

};

template <typename F, typename X>

concept valid_custom_is_operator = predicate_member_fun<X, F, &F::op_is>

&& (

!defined<argument_of_op_is_t<F>>

|| brace_initializable_to<X, argument_of_op_is_t<F>>

);

template <typename T>

inline constexpr auto move(T&& t) -> decltype(auto) {

return std::move(t);

}

inline constexpr auto max(auto... values) {

return std::max( { values... } );

}

template <class T, class... Ts>

inline constexpr auto is_any = std::disjunction_v<std::is_same<T, Ts>...>;

template <std::size_t Len, std::size_t Align>

struct aligned_storage {

alignas(Align) unsigned char data[Len];

};

template <typename T>

requires requires { *std::declval<T&>(); }

using deref_t = decltype(*std::declval<T&>());

template <typename T>

auto pointer_eq(T const* a, T const* b) {

return std::compare_three_way{}(a, b) == std::strong_ordering::equal;

}

template <std::size_t Index, typename T>

struct type_it {

using type = T;

inline static const std::size_t index = Index;

};

template <typename... Ts, typename F>

constexpr auto type_find_if(F&& fun)

}

template <typename F, template<typename...> class C, typename... Ts>

constexpr auto type_find_if(C<Ts...> const&, F&& fun)

{

return type_find_if<Ts...>(CPP2_FORWARD(fun));

}

template <typename T, typename... Ts>

constexpr auto variant_contains_type(std::variant<Ts...>)

}

template <typename C, typename X>

using constness_like_t =

std::conditional_t<

std::is_const_v<

std::remove_pointer_t<

std::remove_reference_t<X>

>

>,

std::add_const_t<C>,

std::remove_const_t<C>

>;

template<class T, class U>

[[nodiscard]] constexpr auto&& forward_like(U&& x) noexcept

{

constexpr bool is_adding_const = std::is_const_v<std::remove_reference_t<T>>;

if constexpr (std::is_lvalue_reference_v<T&&>)

{

if constexpr (is_adding_const)

return std::as_const(x);

else

return static_cast<U&>(x);

}

else

{

if constexpr (is_adding_const)

return std::move(std::as_const(x));

else

return std::move(x);

}

}

#ifdef CPP2_USE_SOURCE_LOCATION

#define CPP2_SOURCE_LOCATION_PARAM , [[maybe_unused]] std::source_location where

#define CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT , [[maybe_unused]] std::source_location where = std::source_location::current()

#define CPP2_SOURCE_LOCATION_PARAM_SOLO [[maybe_unused]] std::source_location where

#define CPP2_SOURCE_LOCATION_ARG , where

#define CPP2_SOURCE_LOCATION_VALUE (cpp2::to_string(where.file_name()) + "(" + cpp2::to_string(where.line()) + ") " + where.function_name())

#else

#define CPP2_SOURCE_LOCATION_PARAM

#define CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT

#define CPP2_SOURCE_LOCATION_PARAM_SOLO

#define CPP2_SOURCE_LOCATION_ARG

#define CPP2_SOURCE_LOCATION_VALUE std::string("")

#endif

#define CPP2_MESSAGE_PARAM char const*

#define CPP2_CONTRACT_MSG cpp2::message_to_cstr_adapter

inline auto message_to_cstr_adapter( CPP2_MESSAGE_PARAM msg ) -> CPP2_MESSAGE_PARAM { return msg ? msg : ""; }

inline auto message_to_cstr_adapter( std::string const& msg ) -> CPP2_MESSAGE_PARAM { return msg.c_str(); }

class contract_group {

};

[[noreturn]] inline auto report_and_terminate(std::string_view group, CPP2_MESSAGE_PARAM msg = "" CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT) noexcept -> void {

}

auto inline cpp2_default = contract_group(

[](CPP2_MESSAGE_PARAM msg CPP2_SOURCE_LOCATION_PARAM)noexcept {

report_and_terminate("Contract", msg CPP2_SOURCE_LOCATION_ARG);

}

);

auto inline bounds_safety = contract_group(

[](CPP2_MESSAGE_PARAM msg CPP2_SOURCE_LOCATION_PARAM)noexcept {

report_and_terminate("Bounds safety", msg CPP2_SOURCE_LOCATION_ARG);

}

);

auto inline null_safety = contract_group(

[](CPP2_MESSAGE_PARAM msg CPP2_SOURCE_LOCATION_PARAM)noexcept {

report_and_terminate("Null safety", msg CPP2_SOURCE_LOCATION_ARG);

}

);

auto inline type_safety = contract_group(

[](CPP2_MESSAGE_PARAM msg CPP2_SOURCE_LOCATION_PARAM)noexcept {

report_and_terminate("Type safety", msg CPP2_SOURCE_LOCATION_ARG);

}

);

auto inline testing = contract_group(

[](CPP2_MESSAGE_PARAM msg CPP2_SOURCE_LOCATION_PARAM)noexcept {

report_and_terminate("Testing", msg CPP2_SOURCE_LOCATION_ARG);

}

);

namespace impl {

template<typename T>

concept UniquePtr = std::is_same_v<T, std::unique_ptr<typename T::element_type, typename T::deleter_type>>;

template<typename T>

concept SharedPtr = std::is_same_v<T, std::shared_ptr<typename T::element_type>>;

template<typename T>

concept Optional = std::is_same_v<T, std::optional<typename T::value_type>>;

#ifdef __cpp_lib_expected

template<typename T>

concept Expected = std::is_same_v<T, std::expected<typename T::value_type, typename T::error_type>>;

#endif

auto assert_not_null(auto&& arg CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT) -> decltype(auto)